WEBVTT

00:05.160 --> 00:08.660
Hallo und herzlich willkommen zur SVT1-Vorlesung.

00:09.780 --> 00:12.620
Wenn Sie sich jetzt fragen, was macht dieser Übungsleiter da vorne,

00:12.720 --> 00:16.860
wenn heute doch Vorlesung ist, das liegt daran, dass Professor Tichy

00:16.860 --> 00:18.000
leider verhindert ist.

00:19.000 --> 00:21.460
Das heißt, Sie müssen mit mir Vorlieb nehmen.

00:21.540 --> 00:22.740
Ich hoffe, das ist in Ordnung für Sie.

00:24.060 --> 00:28.680
Damit sich ansonsten nicht so viel ändert, habe ich Ihnen ein kleines

00:28.680 --> 00:30.560
Java -Rätsel mitgebracht.

00:30.560 --> 00:33.720
Das hört heute auf diesen wundervollen Namen fauler Haufen.

00:34.700 --> 00:38.280
Und wir schauen uns jetzt mal an, was dieser faule Haufen denn tut.

00:39.500 --> 00:45.280
Wir haben eine Glommer-Klasse mit zwei Methoden, die beide Glom

00:45.280 --> 00:45.620
heißen.

00:45.660 --> 00:47.560
Sie sind also überladen.

00:49.280 --> 00:53.540
Die erste Glom-Methode nimmt so ziemlich alles, was in irgendeiner

00:53.540 --> 00:59.100
Collection drinne steckt und konkateniert das als deren String

00:59.100 --> 01:03.120
-Repräsentation, was immer da auch als Objekt reinkommt und gibt das

01:03.120 --> 01:03.680
dann zurück.

01:04.780 --> 01:13.300
Die zweite Glom-Methode nimmt nur Listen von Integers und addiert

01:13.300 --> 01:17.360
diese auf und gibt das Ergebnis zurück.

01:18.940 --> 01:22.440
Das heißt also, wir machen immer irgendeine Art Aggregation.

01:23.240 --> 01:27.240
Und hier unten sehen Sie dann, haben wir eine kleine Main, die eine

01:27.240 --> 01:29.480
Liste von Strings aufbaut.

01:29.640 --> 01:30.840
In dem Fall 1, 2, 3.

01:31.880 --> 01:39.520
Und dann die Glommer-Klasse instanziiert und Glom mit dieser Liste von

01:39.520 --> 01:40.560
Strings aufruft.

01:41.960 --> 01:43.940
Sieht erstmal ganz einfach aus.

01:44.040 --> 01:46.640
Die Frage ist, was passiert?

01:47.660 --> 01:50.280
Ich habe Ihnen da mal eine kleine Auswahl mitgebracht.

01:50.280 --> 01:54.060
Erste Möglichkeit, es wird 6 ausgegeben.

01:55.560 --> 01:59.340
Wer meint denn, dass diese Möglichkeit zutrifft?

02:02.020 --> 02:03.180
Ich sehe keinen.

02:04.180 --> 02:06.040
Möchte keiner für den Außenseiter stimmen?

02:08.720 --> 02:09.400
Okay.

02:10.660 --> 02:14.660
Wer ist der Meinung, dass 1, 2, 3 ausgegeben wird?

02:15.580 --> 02:16.140
Ja, wunderbar.

02:16.280 --> 02:17.200
Hier jemand im Vorbeigehen.

02:17.580 --> 02:18.860
Das sind schon ein paar Hände mehr.

02:19.880 --> 02:21.000
Vielleicht so 10.

02:22.280 --> 02:23.520
Gut, wir sind heute auch nicht so viele.

02:23.680 --> 02:26.540
Vielleicht ist es dann trotzdem schon ein ganz guter Anteil.

02:28.600 --> 02:31.840
Wer sagt denn, es tritt eine Ausnahme auf?

02:33.920 --> 02:34.920
Ja, zögerlich.

02:37.520 --> 02:39.060
Ist das Beispiel zu schwierig?

02:41.960 --> 02:45.140
Oder gehen alle davon aus, dass nichts davon passiert und irgendetwas

02:45.140 --> 02:46.200
anderes seltsames?

02:46.200 --> 02:46.800
Wer meint das?

02:48.860 --> 02:51.280
Er ist immer sicher, dann braucht man nicht sagen, was das denn sein

02:51.280 --> 02:51.600
könnte.

02:52.180 --> 02:52.600
Sehr gut.

02:54.820 --> 03:00.180
Also die paar Zögerlichen, die sich für die Variante C gemeldet haben,

03:00.860 --> 03:01.760
haben tatsächlich recht.

03:02.680 --> 03:04.600
Es tritt eine Ausnahme auf.

03:05.380 --> 03:08.620
Vielleicht ist irgendjemand so mutig von dieser Gruppe, die sich dort

03:08.620 --> 03:10.980
gemeldet hat und sagt uns, was denn da passiert.

03:11.740 --> 03:13.260
Vielleicht hat ja jemand eine Idee.

03:17.200 --> 03:22.140
Sie meinen also, dass das Integer-Objekt hier ein Wrapper um den

03:22.140 --> 03:23.800
primitiven Datentyp ist, ist das Problem?

03:24.400 --> 03:27.340
Sind Sie denn der Meinung, dass wenn hier unten Glom aufgerufen wird,

03:27.440 --> 03:29.740
diese Methode aufgerufen wird oder wird die aufgerufen?

03:30.280 --> 03:30.960
Ja, gut.

03:33.020 --> 03:35.520
Okay, vielleicht machen wir darüber mal kurz eine Abstimmung.

03:35.620 --> 03:36.480
Was passiert denn?

03:37.400 --> 03:41.260
Wird die obere Glom-Methode aufgerufen oder die untere?

03:42.140 --> 03:43.440
Wer stimmt denn für die obere?

03:45.440 --> 03:46.940
Ja, das sind schon ein paar mehr.

03:48.900 --> 03:51.340
Okay, wer meint die untere Glom-Methode?

03:53.100 --> 03:53.680
Keiner?

03:54.620 --> 03:55.260
Das ist interessant.

03:57.680 --> 03:59.040
Ich gebe Ihnen mal einen Tipp.

03:59.740 --> 04:02.680
Es wird eine ClassCastException ausgelöst.

04:05.680 --> 04:08.860
Jetzt hätte ich eigentlich mit einem O, warum das, gerechnet.

04:09.780 --> 04:11.420
Kann sich vielleicht jemand vorstellen, warum?

04:12.720 --> 04:15.500
Also, ich halte mal kurz fest, Sie sind der Meinung, dass diese

04:15.500 --> 04:16.700
Methode aufgerufen wird.

04:16.960 --> 04:19.520
Das ist schon mal richtig, erstaunlicherweise.

04:20.820 --> 04:22.440
Die Frage ist, wie kann das jetzt passieren?

04:22.520 --> 04:25.100
Wir haben doch hier eine Liste von Strings und die Methode hier oben,

04:25.240 --> 04:26.680
die nimmt doch nur ListOfInteger.

04:28.180 --> 04:29.560
Da ist doch irgendwas schief gelaufen.

04:32.140 --> 04:35.880
Und was da schief gelaufen ist, ist diese Stelle.

04:37.900 --> 04:41.160
Ich weiß nicht, ob Sie es gesehen haben, aber unsere Klasse Glamour

04:41.160 --> 04:41.860
ist typisiert.

04:43.340 --> 04:46.320
Und hier unten geben wir keinen Typ an.

04:47.280 --> 04:50.460
Das sieht jetzt erstmal so aus, als wäre das ja kein Problem, denn

04:50.460 --> 04:53.040
dieser Typ T, der wird ja eh nirgends benutzt.

04:53.980 --> 04:54.520
Ja, das stimmt.

04:54.520 --> 05:01.360
Das Problem dabei ist, wenn ich keinen Typ angebe, dann lande ich in

05:01.360 --> 05:03.220
einem Raw-Type-Mode für meinen Objekt.

05:03.340 --> 05:07.600
Das heißt, bei der Instanziierung ignoriert mein Objekt plötzlich alle

05:07.600 --> 05:08.720
Typen, die es kennt.

05:09.360 --> 05:13.480
Das bedeutet auch, dieses Integer wird ignoriert.

05:13.840 --> 05:16.380
Das heißt, diese zweite Methode nimmt plötzlich alle Listen.

05:17.180 --> 05:20.640
Und das ist genau das Problem, warum dann hier eine ClassCastException

05:20.640 --> 05:22.300
ausgelöst wird.

05:24.520 --> 05:25.760
Das sehen Sie aber nicht.

05:26.480 --> 05:28.720
Das ist kein Fehler, wenn Sie das implementieren, sieht das alles

05:28.720 --> 05:30.140
erstmal gut aus, wie das häufig so ist.

05:30.240 --> 05:32.240
Aber es gibt eine Warnung.

05:33.520 --> 05:35.580
Zumindest mal die hier sehen Sie auch in den Clips.

05:37.040 --> 05:39.420
Wir haben unchecked or unsafe operations.

05:40.240 --> 05:44.320
Das sind diese gelben Warnungen, die Sie da ab und zu mal sehen und

05:44.320 --> 05:47.420
wahrscheinlich als Zweitsemester häufiger einfach mal ignorieren.

05:48.000 --> 05:49.280
Das sollten Sie nicht tun.

05:51.380 --> 05:55.320
Jetzt ist die Frage, wie kann man das denn reparieren?

05:55.760 --> 05:59.100
Die einfachste Variante ist zunächst einmal, wenn der Typ

05:59.100 --> 06:01.540
offensichtlich das Problem ist, dann geben wir hier einen Typ an.

06:02.360 --> 06:04.740
Lustigerweise ist es völlig egal, was wir für einen Typ angeben.

06:04.800 --> 06:07.740
Wir können hier unten long angeben, wir können string angeben.

06:08.220 --> 06:09.020
Es ist völlig egal.

06:10.460 --> 06:14.620
Unsere Instanz ist dann richtig typisiert und achtet dann wieder auf

06:14.620 --> 06:15.440
die richtigen Typen.

06:16.640 --> 06:18.520
Dass der nicht benutzt wird, ist völlig egal.

06:18.520 --> 06:20.220
Und deshalb können Sie auch angeben, was Sie wollen.

06:23.520 --> 06:28.040
Jetzt sollte hoffentlich jemand von Ihnen sagen, ja, das ist doch

06:28.040 --> 06:30.640
blöd, wenn wir den Typ da oben sowieso nicht brauchen, dann können wir

06:30.640 --> 06:31.460
ihn doch einfach wegnehmen.

06:32.780 --> 06:35.640
Genau, das ist auch die deutlich bessere Variante.

06:36.460 --> 06:40.500
Wir brauchen den Typ Parameter für die Clummer Klasse eh nicht, also

06:40.500 --> 06:41.400
löschen wir ihn einfach weg.

06:43.360 --> 06:45.460
Es gibt aber noch eine deutlich bessere Lösung.

06:45.460 --> 06:48.920
Und jetzt bekommen Sie nochmal 20 Sekunden Zeit, darüber nachzudenken.

06:49.120 --> 06:52.420
Und dann darf mir jemand sagen, was denn noch eine bessere Lösung für

06:52.420 --> 06:53.220
das Problem wäre.

06:55.200 --> 06:57.300
Ja, da oben kommen gerade zwei Kandidaten.

06:58.440 --> 06:58.680
Drei.

07:00.180 --> 07:01.700
Wissen Sie, wie man das besser lösen kann?

07:04.160 --> 07:06.640
Sie bekommen auch nochmal die 20 Sekunden, die ich allen versprochen

07:06.640 --> 07:06.900
hatte.

07:09.140 --> 07:10.540
Ich sehe schon, sie ducken sich ab.

07:10.840 --> 07:12.920
Hat jemand anders eine Idee, wie man das noch besser lösen kann?

07:16.270 --> 07:17.070
Sie vielleicht?

07:19.930 --> 07:20.870
Gut, das dachte ich mir.

07:21.090 --> 07:25.390
Also, was man tun kann, wir machen einfach eine statische Hilfsklasse

07:25.390 --> 07:25.770
draus.

07:27.590 --> 07:31.110
Also unsere Clummer Instanz, die wir erzeugen würden, die hat eh

07:31.110 --> 07:31.810
keinen Zustand.

07:32.610 --> 07:35.230
Also können wir einfach das Ganze statisch machen, statische Methoden.

07:35.670 --> 07:38.270
Und dann ist das einfach eine Hilfsklasse und schon haben wir die

07:38.270 --> 07:40.750
ganzen Probleme, die wir bisher hatten, nicht mehr.

07:40.750 --> 07:44.110
So, was haben Sie jetzt daraus gelernt?

07:44.270 --> 07:50.190
Hoffentlich verwenden Sie generische Typen nie, nie, nochmal dreimal

07:50.190 --> 07:53.850
unterstrichen zu dem fetten dazu, nie unparametrisiert.

07:54.610 --> 07:57.590
Sie kriegen da immer, immer Probleme, denn diese Raw Types, die

07:57.590 --> 08:01.350
verlieren sämtliche Informationen über ihre generischen Typen.

08:02.810 --> 08:06.370
Und wie Sie gerade gesehen haben, führt das insbesondere beim Aufruf

08:06.370 --> 08:09.530
von überladenen Methoden dann zu großen Problemen.

08:10.450 --> 08:14.610
Und wenn Ihnen das jetzt als Lehre ein bisschen zu speziell ist, dann

08:14.610 --> 08:17.470
die Metalehre dieses Beispiels.

08:18.310 --> 08:20.690
Bitte beherzigen Sie Warnungen.

08:22.230 --> 08:26.250
Wenn Sie etwas implementieren und haben da in jeder dritten Zeile in

08:26.250 --> 08:32.210
Eclipse gelb unterstrichene Stellen mit Warnung, dann haben Sie

08:32.210 --> 08:33.070
irgendwas falsch gemacht.

08:33.230 --> 08:34.530
Ignorieren Sie das nicht.

08:35.670 --> 08:38.350
Und vielleicht noch so ein anderer kleiner Hinweis, dann die

08:38.350 --> 08:41.730
Autokorrektur, die Eclipse dann manchmal vorschlägt, sowas wie

08:41.730 --> 08:44.050
Suppressed Warnings.

08:45.210 --> 08:47.550
Klar kann man machen, dann weiß man, dass da die Fehler auftreten

08:47.550 --> 08:48.990
werden, aber das ist keine Lösung.

08:49.290 --> 08:52.470
Also kümmern Sie sich darum, dass Ihr Code keine Warnungen erzeugt.

08:53.230 --> 08:56.950
Kümmern Sie sich darum, dass Sie sinnvolle Dinge implementieren und

08:56.950 --> 08:58.310
möglichst keine Warnungen erzeugen.

08:59.330 --> 09:01.950
Gut, das soweit dazu.

09:02.170 --> 09:04.430
Hat dazu vielleicht noch jemand eine Frage?

09:07.050 --> 09:07.810
Keine Fragen?

09:08.810 --> 09:10.730
Alle verstanden, dass Warnungen gemein sind?

09:11.630 --> 09:11.990
Sehr schön.

09:12.850 --> 09:19.290
Gut, dann machen wir mit der Vorlesung weiter.

09:20.630 --> 09:25.490
Sie haben sich letzte Woche, nein, es stimmt gar nicht, am Montag

09:25.490 --> 09:30.350
wahrscheinlich, mit Professor Tichy über Architekturstile unterhalten,

09:30.490 --> 09:35.230
haben etwas über Fließbänder kennengelernt, über Rahmenarchitekturen

09:35.230 --> 09:38.130
und ich glaube, das ist genau die Stelle, wo Sie stehen geblieben

09:38.130 --> 09:38.330
sind.

09:38.410 --> 09:40.250
Korrigieren Sie mich, wenn ich da jetzt falsch liege.

09:40.890 --> 09:42.210
Aber das soweit meine Informationen.

09:43.850 --> 09:45.030
Was haben Sie noch kennengelernt?

09:45.110 --> 09:45.590
MVC.

09:46.950 --> 09:48.770
Kleiner Hinweis, ganz wichtig.

09:48.770 --> 09:53.670
Wir machen jedes Semester mit unseren Neututoren Castings und dann

09:53.670 --> 09:57.270
stellen wir unter anderem die Frage, was habt ihr denn schon mal aus

09:57.270 --> 09:58.090
der SVT benutzt?

09:58.910 --> 10:02.030
Auf Platz 1 ist dann immer MVC, haben wir tatsächlich schon mal

10:02.030 --> 10:02.330
gebaut.

10:02.490 --> 10:05.950
Und die sind nur zwei Semester weiter als Sie im Normalfall.

10:07.610 --> 10:10.390
Insofern nehmen Sie das wirklich als wichtig an.

10:12.090 --> 10:14.670
Was jetzt als nächstes und letztes noch kommt, sind diese

10:14.670 --> 10:16.830
dienstorientierten Architekturen.

10:18.550 --> 10:22.370
Dazu müssen Sie im Kopf ein Stückchen weggehen von dem, was Sie sonst

10:22.370 --> 10:26.950
so tun beim Programmieren in Eclipse oder sonst auch so beim

10:26.950 --> 10:27.370
Entwickeln.

10:27.870 --> 10:33.530
Hier geht man davon aus, es gibt einen Dienstgeber, der bietet mir

10:33.530 --> 10:35.370
einen gewissen Dienst an, den er für mich löst.

10:35.370 --> 10:44.990
Und es gibt Dienstnehmer, die gerne diese Dienste in Anspruch nehmen

10:44.990 --> 10:48.490
möchten und die wissen erstmal nichts davon.

10:49.330 --> 10:57.390
Der Dienstgeber, soweit die Idee, steht normalerweise irgendwo

10:57.390 --> 10:58.150
entfernt.

10:58.330 --> 11:01.010
Das ist genau der Grund, warum man das auch möglichst lose koppeln

11:01.010 --> 11:01.310
möchte.

11:01.310 --> 11:05.430
Man möchte nur wissen, was kann der mir anbieten als Dienstnehmer und

11:05.430 --> 11:08.850
möchte das dann von diesem Dienst entgegennehmen können.

11:10.210 --> 11:17.010
Das Ganze hat noch ein paar ganz nette Nebeneffekte von der Idee her.

11:17.790 --> 11:21.050
Man kann da ganz gut Unternehmensprozesse drin kapseln.

11:21.050 --> 11:25.970
Also die Idee war im Falle von SOA, ich werde gleich sehen, warum ich

11:25.970 --> 11:30.470
da in der Vergangenheit spreche, war, wir haben ein Unternehmen und

11:30.470 --> 11:33.650
das möchte gerne gewisse Aufgaben lösen.

11:34.250 --> 11:38.970
Und dazu spricht es nur noch externe Dienstgeber, die irgendwo liegen

11:38.970 --> 11:40.750
und ihre Dienste zur Verfügung stellen an.

11:41.790 --> 11:45.570
Und das hat diese netten Nebeneffekte, dass man zum einen die lose

11:45.570 --> 11:47.350
Kopplung hat, wie ich gerade eben schon gesagt habe.

11:47.350 --> 11:51.990
Und man kann eben ganz gut, wenn ein Dienst wegfällt, ein neuer Dienst

11:51.990 --> 11:55.090
vielleicht angeboten wird, der das gleiche leistet, aber besser kann

11:55.090 --> 11:57.650
man den stattdessen anbinden.

11:58.890 --> 12:06.710
Das Ganze soll über eine Dienstbeschreibung funktionieren, die im

12:06.710 --> 12:11.250
Grunde die Schnittstelle zwischen Dienstgeber und Dienstnehmer bildet.

12:11.410 --> 12:15.830
Und das Ganze sollte möglichst sprach- und technologieunabhängig sein.

12:17.450 --> 12:20.170
Und so hat man sich das dann vorgestellt im SOA-Kontext.

12:20.270 --> 12:23.310
Und jetzt sage ich Ihnen ganz kurz, warum in der Vergangenheitsform

12:23.310 --> 12:25.250
SOA ist nicht mehr so ganz hip.

12:27.030 --> 12:29.530
Das funktioniert heutzutage alles ein bisschen anders.

12:29.630 --> 12:31.310
Die Grundidee bleibt aber die gleiche.

12:31.330 --> 12:32.610
Deshalb stellen wir Ihnen das hier vor.

12:33.410 --> 12:38.170
Wir haben einen Dienstanbieter, wie ich gerade eben schon gesagt habe.

12:38.330 --> 12:43.650
Und dieser Dienstanbieter veröffentlicht die Dienste, die er anbieten

12:43.650 --> 12:46.610
kann, in so einem Dienstverzeichnis.

12:47.510 --> 12:51.970
Das können Sie sich ungefähr vorstellen wie ein Telefonbuch, in dem

12:51.970 --> 12:54.890
alle möglichen Dienste verzeichnet sind, die so angeboten werden

12:54.890 --> 12:57.390
können durch unterschiedliche Dienstanbieter.

12:57.390 --> 13:00.590
Und auf der anderen Seite haben wir dann unseren Dienstnutzer.

13:00.730 --> 13:05.170
Das ist vielleicht Ihr Programm, das Sie entwickelt haben, mit dem Sie

13:05.170 --> 13:07.210
einen gewissen Dienst nutzen möchten.

13:08.530 --> 13:12.770
Und Sie als Dienstnutzer fragen dann zunächst einmal das

13:12.770 --> 13:15.630
Dienstverzeichnis an.

13:15.710 --> 13:17.610
Und hier sehen Sie schon die Grundidee.

13:18.190 --> 13:21.350
Dienstanbieter und Dienstnutzer wissen erstmal nichts voneinander.

13:21.790 --> 13:25.550
Wir haben dort erstmal keine 1 zu 1 Beziehungen zwischen den beiden.

13:25.550 --> 13:30.270
Der Dienstanbieter bietet Dienste an, über ein standardisiertes

13:30.270 --> 13:30.670
Format.

13:31.070 --> 13:34.190
Und der Dienstnutzer sucht nach Diensten über ein standardisiertes

13:34.190 --> 13:34.470
Format.

13:34.530 --> 13:36.290
Sie wissen aber zunächst einmal nichts voneinander.

13:37.130 --> 13:42.050
In diesem Dienstverzeichnis finde ich dann den Verweis auf den Dienst,

13:42.150 --> 13:44.750
den ich benutzen kann, für meine Funktionalität, die ich gerne hätte.

13:47.290 --> 13:50.810
Und wenn ich das dann habe, kann ich tatsächlich die Verbindung zu dem

13:50.810 --> 13:53.050
Dienst, den ich benutzen möchte, aufbauen.

13:53.050 --> 13:58.570
Die Dienstbeschreibung mir abholen und letztendlich den Dienst nutzen.

14:00.150 --> 14:04.370
Eigentlich eine ganz einfache Idee, muss man trotzdem mal gesehen

14:04.370 --> 14:04.690
haben.

14:08.910 --> 14:11.690
Das wurde natürlich auch noch genutzt.

14:12.250 --> 14:15.170
Wird auch heutzutage noch genutzt, auch wenn es nicht mehr ganz so hip

14:15.170 --> 14:15.330
ist.

14:15.570 --> 14:21.010
Und so ähnlich wird es auch immer noch anders genutzt, mit anderen

14:21.010 --> 14:21.430
Standards.

14:22.590 --> 14:27.170
Aber trotzdem haben wir jetzt mal noch die aufgelistet, die hier

14:27.170 --> 14:28.430
tatsächlich zu SOA gehören.

14:29.490 --> 14:29.990
Das ist ganz wichtig.

14:30.110 --> 14:32.730
Ich habe gerade eben schon gesagt, es geht darum, damit Geschäfte zu

14:32.730 --> 14:33.490
machen, Geld zu verdienen.

14:33.650 --> 14:36.650
Und wenn es darum geht, ist es ganz wichtig, sich Wörter auszudenken,

14:36.710 --> 14:38.910
die keiner versteht, wenn sie dann dem Kunden das verkaufen wollen.

14:40.090 --> 14:43.850
Und deshalb gibt es hier diese wunderschönen Abkürzungen oder Akronyme

14:43.850 --> 14:46.390
WSDL, UDDI und SOAP.

14:47.910 --> 14:52.610
Wir sehen zum einen das, was der Dienstanbieter da veröffentlicht.

14:52.730 --> 14:56.550
Das funktioniert über die Web Service Description Language.

14:57.230 --> 15:02.930
Das ist einfach eine Art standardisiertes XML-Dokument, wo im Grunde

15:02.930 --> 15:07.710
drin steht, was kann ich, was für einen Dienst biete ich an, wie biete

15:07.710 --> 15:10.970
ich den an, über welchen Port kann ich erreicht werden und so weiter

15:10.970 --> 15:11.350
und so fort.

15:11.730 --> 15:14.250
Und das wird dann hier oben in dieses Dienstverzeichnis eingetragen.

15:14.990 --> 15:18.090
Aber auch das Dienstverzeichnis heißt nicht einfach Dienstverzeichnis,

15:18.210 --> 15:20.730
damit das ein bisschen wichtiger klingt, heißt das Universal

15:20.730 --> 15:23.090
Description Discovery and Integration.

15:24.650 --> 15:27.970
Und dort sind dann die ganzen Dienste verzeichnet und können über das

15:27.970 --> 15:32.310
SOAP -Protokoll von Dienstnehmern angesprochen werden.

15:32.510 --> 15:36.330
SOAP steht zunächst einmal in der ursprünglichen Variante für Simple

15:36.330 --> 15:38.090
Object Access Protocol.

15:40.050 --> 15:45.270
Im Verlauf der Jahre, SOAP ist jetzt auch schon 16, 17 Jahre alt,

15:45.390 --> 15:48.690
glaube ich, hat dieser Name dann häufiger mal gewechselt.

15:48.750 --> 15:52.590
Das lag hauptsächlich daran, dass man festgestellt hat, mit Simple hat

15:52.590 --> 15:55.530
das wenig zu tun, mit Objects noch weniger.

15:56.610 --> 16:00.890
Dementsprechend hat man sich dann häufiger mal andere Übersetzungen

16:00.890 --> 16:03.590
ausgedacht, haben aber alle nicht so ganz gepasst.

16:03.690 --> 16:06.070
Deshalb spricht man heutzutage nur noch von SOAP, klingt ja auch ganz

16:06.070 --> 16:06.290
hübsch.

16:07.230 --> 16:09.890
Das heißt, das Akronym ist geblieben, eine Bedeutung gibt es dafür

16:09.890 --> 16:10.550
nicht mehr so wirklich.

16:11.310 --> 16:15.990
Aber auch das ist einfach eine Art standardisiertes XML-Protokoll, mit

16:15.990 --> 16:20.130
dem Sie Ihre Anfragen an das Dienstverzeichnis stellen können und dann

16:20.130 --> 16:23.050
auch mit dem Dienstanbieter tatsächlich kommunizieren.

16:25.690 --> 16:28.050
Hier nochmal die Merkmale.

16:29.190 --> 16:31.910
Ich glaube, das habe ich alles schon im Wesentlichen gesagt.

16:31.910 --> 16:37.910
Wir haben diese lose Kopplung und können unsere Dienste, die wir

16:37.910 --> 16:41.870
benutzen wollen, je nachdem wie sie zur Verfügung stehen, auch

16:41.870 --> 16:42.410
ansprechen.

16:42.550 --> 16:48.030
Das heißt auch, wir können über unsere Laufzeit unseres Programms den

16:48.030 --> 16:49.030
Dienst vielleicht auch wechseln.

16:49.590 --> 16:50.730
Das ist die eigentliche Idee.

16:50.890 --> 16:54.030
Das heißt, wenn wir einen anderen Dienstanbieter haben, der das

16:54.030 --> 16:57.350
Gleiche für uns leistet, dann können wir das zumindest in der Theorie

16:57.350 --> 16:58.930
einfach auswechseln.

16:58.930 --> 17:01.570
Ob das dann tatsächlich so funktioniert, weil der vielleicht doch

17:01.570 --> 17:04.990
andere Dinge uns antwortet, als wir erwarten, das steht auf einem

17:04.990 --> 17:06.150
anderen Blatt.

17:06.970 --> 17:08.470
Aber die Idee ist das zumindest.

17:09.170 --> 17:11.490
Die Unterstützung der Geschäftsprozesse hatte ich auch schon

17:11.490 --> 17:15.230
angesprochen und auch die Verwendung der offenen Standards.

17:15.470 --> 17:19.090
Wir sind an der Stelle völlig oder fast Programmiersprachen und

17:19.090 --> 17:20.370
Plattformen unabhängig.

17:20.450 --> 17:23.590
Dadurch, dass wir diese standardisierten Formate haben, können wir in

17:23.590 --> 17:26.750
unserem Dienstnehmer programmieren, was wir wollen.

17:26.750 --> 17:29.910
Java, C, PHP, machen Sie, was Sie wollen.

17:30.910 --> 17:35.030
Und dann können Sie die Dienste über das Zauberprotokoll ansprechen.

17:36.490 --> 17:40.130
Das war es soweit zu den Architekturstilen.

17:40.890 --> 17:42.330
Also, Entwurfsmuster.

17:45.350 --> 17:49.910
Wir haben jedes Jahr das Problem mit quengelnden Studenten, diese

17:49.910 --> 17:50.550
Entwurfsmuster.

17:50.670 --> 17:53.450
Das ist ja so langweilig und tröge und warum erzählt ihr uns das

17:53.450 --> 17:53.730
alles?

17:53.730 --> 17:56.290
Der Grund ist, es ist wichtig.

17:58.690 --> 18:01.430
Jetzt sehen Sie das vielleicht im zweiten Semester noch nicht so ganz.

18:02.930 --> 18:06.870
Deshalb beginne ich an der Stelle mal mit einer kleinen Anekdote.

18:07.470 --> 18:12.390
Ich habe mich vor kurzem mit einem befreundeten Softwareentwickler

18:12.390 --> 18:13.770
unterhalten.

18:14.390 --> 18:18.170
Der arbeitet in so einer ganz hippen Software-Schmiede.

18:18.770 --> 18:23.830
So ganz flache Hierarchien, agile Prozesse, agile Entwicklung.

18:24.510 --> 18:27.170
So wie man halt heutzutage denkt, dass man mit Software Geld verdienen

18:27.170 --> 18:27.470
könnte.

18:29.190 --> 18:32.370
Und der wollte dann von mir wissen, was ich denn eigentlich so in der

18:32.370 --> 18:35.350
SBT immer erzähle, was wir denn da so lernen.

18:35.470 --> 18:37.630
Und ich habe dann angefangen so aufzuzählen und ich habe dann schon

18:37.630 --> 18:39.790
gemerkt, wie das Interesse so langsam weniger wurde.

18:39.790 --> 18:42.170
Der Blick schweifte dann immer schon mal weg.

18:43.370 --> 18:45.170
Und ja, das hat mich aber nicht interessiert.

18:45.250 --> 18:46.470
Das merken Sie jetzt vielleicht auch schon.

18:46.530 --> 18:47.890
Wenn jemand nicht zuhört, rede ich trotzdem weiter.

18:49.750 --> 18:52.670
Und ich habe dann einfach mal weiter aufgezählt und irgendwann sagte

18:52.670 --> 18:54.810
ich dann halt, wir machen auch Entwurfsmuster.

18:55.250 --> 18:57.770
Und in dem Moment sagt er, super, macht das mal noch ein bisschen

18:57.770 --> 18:58.070
besser.

18:58.730 --> 19:01.370
Erklärt den Studenten mal noch ein bisschen mehr zu Entwurfsmustern,

19:01.650 --> 19:02.470
denn das ist super wichtig.

19:02.590 --> 19:06.050
Das ist das Einzige, womit man sich sinnvoll unterhalten kann, wenn

19:06.050 --> 19:08.050
man Entwickler ist, mit anderen Entwicklern.

19:08.050 --> 19:10.850
Also zur Kommunikation im Team ist das unglaublich wichtig.

19:11.190 --> 19:14.390
Und er sagte auch seiner Erfahrung nach, die Leute, die Ahnung haben

19:14.390 --> 19:17.110
von Entwurfsmustern, die schreiben deutlich, deutlich, deutlich

19:17.110 --> 19:17.850
besseren Code.

19:18.170 --> 19:20.570
Den kann man lesen, den kann man verstehen, da kann man drüber reden.

19:22.390 --> 19:25.710
Das schweifte dann noch so ein bisschen ab und wurde zum zweistelligen

19:25.710 --> 19:26.410
Fachgespräch.

19:26.870 --> 19:28.070
Das gebe ich jetzt nicht ganz wieder.

19:28.150 --> 19:29.290
Das glaube ich auch in Ihrem Interesse.

19:29.790 --> 19:33.210
Aber was Sie vielleicht mitbekommen haben, Entwurfsmuster sind

19:33.210 --> 19:33.610
wichtig.

19:33.610 --> 19:36.110
Nicht nur hier für die Vorlesung, nicht nur für die Klausur, da

19:36.110 --> 19:39.890
versprochen auch, aber auch für Ihr Leben als Informatiker.

19:40.170 --> 19:44.130
Das heißt, nehmen Sie sich das an, versuchen Sie, Entwurfsmuster zu

19:44.130 --> 19:44.310
lernen.

19:45.450 --> 19:48.250
Es gibt da auch noch ein ganz gutes Buch dazu, falls Sie da Interesse

19:48.250 --> 19:48.430
haben.

19:48.510 --> 19:49.810
Darauf komme ich nachher eh noch zu sprechen.

19:50.990 --> 19:57.290
Fangen wir erst mal an mit der Definition der Entwurfsmuster.

19:57.950 --> 20:02.330
Ein Software-Entwurfsmuster beschreibt eine Familie von Lösungen für

20:02.330 --> 20:04.810
ein Software-Entwurfsproblem.

20:06.130 --> 20:07.110
Was heißt das jetzt?

20:08.530 --> 20:13.010
Das heißt, Sie müssen ein Entwurfsmuster immer als Tupel sehen von

20:13.010 --> 20:15.010
Problem und Lösung.

20:16.390 --> 20:19.650
Sie werden feststellen, dass Sie als Informatiker immer wieder mal

20:19.650 --> 20:22.750
über ähnliche Probleme stolpern werden.

20:24.230 --> 20:27.810
Natürlich ist immer, wenn Sie etwas entwickeln, Ihr Problem einmalig.

20:28.590 --> 20:31.090
Sonst würden Sie dafür hoffentlich nicht so gut bezahlt werden.

20:31.810 --> 20:35.070
Aber Sie werden feststellen, wenn Sie das Problem dann runterbrechen

20:35.070 --> 20:38.350
in viele kleine Teilprobleme, sehen Sie viele Probleme, die Sie schon

20:38.350 --> 20:40.610
mal gesehen haben oder die man anders schon mal gesehen hat.

20:41.030 --> 20:43.170
Und genau dafür gibt es die Entwurfsmuster.

20:44.010 --> 20:48.830
Das heißt, wir haben gewisse Problemstellungen immer wieder im Entwurf

20:48.830 --> 20:52.930
und es gibt einfach gute Lösungen, die sich jemand anders schon mal

20:52.930 --> 20:54.850
ausgedacht hat.

20:55.890 --> 20:58.050
Warum heißt es dann Familie von Lösungen und nicht einfach nur

20:58.050 --> 20:58.410
Lösungen?

20:58.510 --> 21:02.230
Das liegt daran, dass Entwurfsmuster immer eine gewisse Abstraktion

21:02.230 --> 21:02.530
haben.

21:04.010 --> 21:07.810
Das heißt, für Ihr spezielles Problem müssen Sie sicherlich das

21:07.810 --> 21:10.750
Entwurfsmuster, das Sie kennen, die Sie jetzt gleich kennenlernen

21:10.750 --> 21:12.170
werden, anpassen.

21:12.370 --> 21:16.730
Sie können das nicht fertig so, wie es aus der SVT-Box kommt,

21:16.830 --> 21:19.270
benutzen, sondern Sie müssen immer sehen, wie passt das auf mein

21:19.270 --> 21:20.010
spezielles Problem?

21:20.350 --> 21:21.330
Muss ich das anpassen?

21:21.630 --> 21:22.510
Wie kann ich das benutzen?

21:24.870 --> 21:28.010
Hier im ersten Bullet steht auch schon der wichtigste Zweck der

21:28.010 --> 21:29.270
Entwurfsmuster Wiederverwendung.

21:30.190 --> 21:32.770
Sie wollen nicht ständig das Rad neu erfinden.

21:32.950 --> 21:35.570
Irgendjemand hat sich eine gute Lösung für ein spezielles Problem

21:35.570 --> 21:36.010
überlegt.

21:36.470 --> 21:37.870
Also benutzen wir das.

21:38.610 --> 21:42.870
Abgesehen davon fördern viele Entwurfsmuster tatsächlich die

21:42.870 --> 21:45.810
Wiederverwendbarkeit ihres eigenen Codes.

21:48.110 --> 21:51.250
Und dann steht hier noch die Anmerkung, Entwurfsmuster sind für den

21:51.250 --> 21:54.490
Entwurf, was Algorithmen für das Programmieren im Kleinen sind.

21:54.610 --> 21:58.850
Genau, das sind Ihre Bausteine, die Sie haben, um einen schönen

21:58.850 --> 22:00.790
Entwurf für Ihr Programm zu bauen.

22:03.110 --> 22:07.430
Lustigerweise kommen die Entwurfsmuster eigentlich woanders her,

22:07.530 --> 22:08.690
nämlich aus der Städteplanung.

22:09.530 --> 22:10.810
Da hat man ähnliche Probleme.

22:11.130 --> 22:15.810
Auch jede Stadt ist für sich gesehen ein eigenes, großes, einzelnes

22:15.810 --> 22:18.110
Problem, die richtig zu planen.

22:18.710 --> 22:22.030
Aber auch dort findet man häufig die gleichen Probleme.

22:22.290 --> 22:24.910
Man muss Brücken über Flüsse bauen.

22:25.050 --> 22:29.530
Man muss für Wohngebiete Einkaufszentren möglichst gut platzieren.

22:30.030 --> 22:33.550
Und auch da kann man sich gewisse Muster überlegen, wie man das

22:33.550 --> 22:34.430
möglichst gut macht.

22:36.850 --> 22:38.170
Das heißt, da kommt das her.

22:38.350 --> 22:40.970
Aber wir haben festgestellt, in der Softwaretechnik ist das auch

22:40.970 --> 22:41.490
hilfreich.

22:43.750 --> 22:47.370
Deshalb sind die Entwurfsmuster in der Softwaretechnik gelandet.

22:47.570 --> 22:50.610
Und hier stehen nochmal ein paar gute Gründe, warum wir die benutzen

22:50.610 --> 22:50.950
sollten.

22:51.590 --> 22:54.450
Kommunikation habe ich schon gesagt.

22:55.470 --> 23:00.870
Wenn Sie Entwurfsmuster kennen und wenn Ihre Kollegen Entwurfsmuster

23:00.870 --> 23:03.370
kennen, dann können Sie besser kommunizieren.

23:03.490 --> 23:06.110
Wenn Sie immer auf Code-Ebene sprechen müssen, wird es furchtbar

23:06.110 --> 23:06.690
kompliziert.

23:07.230 --> 23:11.410
Dafür sind unsere Hirne, unsere Denkprozesse nicht ausgelegt.

23:11.670 --> 23:15.850
Aber wenn Sie sagen können, ja, dort würde ich sagen, bauen wir einen

23:15.850 --> 23:19.890
Observer oder einen Beobachter, wie es auf Deutsch heißt, und dort

23:19.890 --> 23:24.030
benutzen wir eine Fassade, dann weiß Ihr Gegenüber, wovon Sie

23:24.030 --> 23:24.370
sprechen.

23:25.410 --> 23:28.170
Und noch viel besser kommt das natürlich, wenn Sie später mal mit

23:28.170 --> 23:29.790
Ihrem Chef sprechen und er kommt mit einem Problem.

23:30.130 --> 23:32.010
Und dann sagen Sie, ja, Chef, kein Problem, da brauche ich einfach

23:32.010 --> 23:32.530
einen Beobachter.

23:33.190 --> 23:34.950
Und dann haben Sie entweder einen guten Chef, der sagt dann, ah ja,

23:35.030 --> 23:36.770
Beobachter, gute Idee, oder er sagt, was, Beobachter?

23:37.430 --> 23:39.850
Das ist noch besser für Sie, dann können Sie erklären, was das denn

23:39.850 --> 23:40.750
ist und warum das toll ist.

23:41.370 --> 23:43.890
Und dann können Sie vielleicht gleich noch eine Gehaltserhöhung

23:43.890 --> 23:44.310
rausschlagen.

23:44.410 --> 23:45.150
Aber das nur so am Rande.

23:47.970 --> 23:52.910
Wichtig ist, dass wir gewisse Entwurfskonzepte in einer einheitlichen

23:52.910 --> 23:54.390
Form darstellen können.

23:54.630 --> 23:58.570
Und das hilft eindeutig später beim Verständnis.

23:59.330 --> 24:02.390
Wenn jemand später mal Ihren Entwurf anschaut und auch Ahnung hat von

24:02.390 --> 24:04.650
Entwurfsmustern, dann sieht er sofort den Beobachter.

24:05.650 --> 24:08.550
Oder dann sieht er sofort den Adapter, den Sie dort gebaut haben im

24:08.550 --> 24:08.870
Entwurf.

24:10.530 --> 24:14.650
Und wenn Sie die richtigen Schlüsselwörter benutzen, zusätzlich noch,

24:14.650 --> 24:20.570
wenn Sie Ihren Beobachter, Observer nennen, dann ist es natürlich auch

24:20.570 --> 24:22.450
noch deutlich leichter für denjenigen, der das liest.

24:22.530 --> 24:24.750
Der weiß dann sofort, okay, hier ist offensichtlich das

24:24.750 --> 24:27.010
Beobachtermuster angewendet worden.

24:27.770 --> 24:33.010
Und wenn Sie ganz konsequent Entwurfsmuster benutzen, dann verhindern

24:33.010 --> 24:35.530
Sie auch diesen berühmten Architekturdrift.

24:35.670 --> 24:39.930
Wenn Sie ein Architekturmuster benutzt haben und jemand anders ändert

24:39.930 --> 24:43.490
etwas, dann wird er einen Teufel tun und dieses Entwurfsmuster

24:43.490 --> 24:43.990
zerstören.

24:44.890 --> 24:47.210
Dann wird er natürlich versuchen, das Leben zu lassen.

24:47.790 --> 24:50.050
Das heißt, Sie können dafür sorgen, dass wenn Sie einheitliche

24:50.050 --> 24:52.070
Bausteine benutzen, die auch stehen bleiben.

24:52.170 --> 24:55.230
Die werden vielleicht angepasst, aber sie werden im Allgemeinen nicht

24:55.230 --> 24:55.650
zerstört.

24:55.790 --> 24:57.890
Wohingegen, wenn Sie einfach frei modellieren, irgendwelche Klassen

24:57.890 --> 25:00.050
nennen, dann denkt sich vielleicht irgendjemand mal, ja, wozu brauche

25:00.050 --> 25:00.850
ich das denn weg damit.

25:02.910 --> 25:06.290
Das heißt, auch dafür sind Entwurfsmuster gut.

25:09.130 --> 25:10.290
Was außerdem noch?

25:10.830 --> 25:13.110
Dokumentieren und fördern und so weiter und so fort.

25:13.170 --> 25:15.270
Das habe ich, glaube ich, auch schon gesagt.

25:15.550 --> 25:17.030
Wichtig ist hier der dritte Unterpunkt.

25:18.430 --> 25:20.870
Wir haben damit keine festen Lösungen.

25:20.970 --> 25:25.170
Wir haben Vorschläge für eine abstrakte Lösung.

25:25.310 --> 25:27.930
Das heißt, Sie müssen das für Ihr konkretes Problem anpassen.

25:28.070 --> 25:29.130
Aber auch das habe ich schon gesagt.

25:29.210 --> 25:32.370
Trotzdem ist es wichtig, das nochmal zu sagen, damit es nicht verloren

25:32.370 --> 25:32.650
geht.

25:34.630 --> 25:37.090
Code -Struktur verbessern, das habe ich, glaube ich, auch schon

25:37.090 --> 25:37.370
gesagt.

25:37.430 --> 25:38.510
Da können wir auch drüber hinweggehen.

25:39.670 --> 25:44.130
Und jetzt machen wir wieder einen ganz weiten Sprung weg zunächst

25:44.130 --> 25:49.010
einmal und sind bei der Apollo 13 Mission als motivierendes

25:49.010 --> 25:50.650
Einführungsbeispiel.

25:52.490 --> 25:53.770
Wer kann sich noch daran erinnern?

25:55.430 --> 25:58.110
Ja, okay, Sie sind alle so jung, dass wahrscheinlich nicht mal Ihre

25:58.110 --> 25:59.170
Eltern sich daran erinnern können.

26:00.630 --> 26:01.750
Doch, hat jemand doch gerufen?

26:03.490 --> 26:05.930
Also, Sie haben es trotzdem bestimmt alle schon mal gehört.

26:05.990 --> 26:08.870
Die Apollo 13 Mission, die, naja, sagen wir mal, ein bisschen schief

26:08.870 --> 26:10.330
gegangen ist damals, 1970.

26:12.070 --> 26:15.490
Was Sie hier auf dieser zugegeben nicht besonders schönen Skizze

26:15.490 --> 26:20.350
sehen, ist zum einen das Mondlandemodul, was man damals benutzen

26:20.350 --> 26:21.770
wollte, um auf den Mond zu landen.

26:21.810 --> 26:25.490
Hier sehen Sie die Füßchen, die dann auf der Oberfläche landen und auf

26:25.490 --> 26:28.630
der anderen Seite das Kommandomodul, wo die drei Astronauten damals

26:28.630 --> 26:30.210
zum Mond gereist sind.

26:31.850 --> 26:33.150
Was ist passiert?

26:33.710 --> 26:40.910
Ungefähr 46 Stunden nach dem Start, glaube ich, ist das Service-Modul

26:40.910 --> 26:44.910
zerstört worden, da ein Sauerstofftank explodiert ist.

26:46.110 --> 26:51.170
Das hatte zur Folge, dass man in diesem Kommandomodul keinen Strom

26:51.170 --> 26:51.810
mehr hatte.

26:52.990 --> 26:57.030
Und dann wird es auch etwas schwierig mit Temperatur, mit

26:57.030 --> 26:59.350
Wassererzeugung, mit Lufterzeugung.

26:59.350 --> 27:02.910
Das heißt, in dem Kommandomodul war es dann nicht mehr so richtig

27:02.910 --> 27:03.170
schön.

27:03.630 --> 27:07.030
Deshalb hat man sich überlegt, okay, wir haben ja hier noch das

27:07.030 --> 27:07.950
Mondlandemodul.

27:08.250 --> 27:11.130
Können wir das vielleicht so als Rettungskapsel benutzen?

27:11.250 --> 27:12.690
Können da die Astronauten unterbringen?

27:13.250 --> 27:14.810
Die Antwort ist ja, natürlich.

27:15.850 --> 27:23.470
Das Problem ist, wir haben dort zu wenig Sauerstoff im Grunde.

27:23.470 --> 27:30.030
Dieses Lithiumhydroxid benutzt man, um den Sauerstoff zu filtern und

27:30.030 --> 27:34.750
dann im Grunde den Sauerstoff bereitzustellen für die Astronauten.

27:34.970 --> 27:38.930
Das hätte in diesem Fall aber nur für 60 Stunden für zwei Astronauten

27:38.930 --> 27:39.250
gebraucht.

27:39.330 --> 27:43.010
Und man brauchte deutlich mehr, nämlich 88 Stunden für drei

27:43.010 --> 27:43.450
Astronauten.

27:43.570 --> 27:45.190
Das heißt, das geht nicht so ganz auf.

27:45.730 --> 27:49.310
Aber hier steht schon der Hinweis, hier in dem Kommandomodul haben wir

27:49.310 --> 27:50.830
offensichtlich genug davon.

27:51.370 --> 27:53.450
Das heißt, wir müssen das jetzt irgendwie darüber bringen.

27:53.930 --> 27:55.150
Das kann ja nicht so schwierig sein.

27:58.310 --> 28:00.910
Genau, das ist jetzt nochmal genau das Problem.

28:01.690 --> 28:07.590
Wir mussten, oder dort musste man die Besatzung evakuieren in dieses

28:07.590 --> 28:09.070
Mondlandemodul.

28:09.650 --> 28:13.090
Und man hätte ja, sollte man doch denken können, einfach diesen

28:13.090 --> 28:16.990
Lithiumhydroxidbehälter des Kommandomoduls benutzen können, um die

28:16.990 --> 28:18.750
Atemluft zu filtern.

28:19.410 --> 28:20.090
Gute Idee.

28:21.590 --> 28:22.450
Funktioniert aber nicht.

28:23.170 --> 28:25.890
Ganz einfach deshalb, weil diese beiden eigentlich gleichartigen

28:25.890 --> 28:29.490
Module im Kommandomodul und im Mondlandemodul nicht kompatible

28:29.490 --> 28:30.170
Anschlüsse hatten.

28:32.470 --> 28:33.430
Ja, blöd gelaufen.

28:34.310 --> 28:35.250
So, was macht man?

28:36.490 --> 28:38.850
Man guckt mal so, was man denn so dabei hat.

28:39.630 --> 28:42.590
Was hat man so dabei auf so einer Mondlandemission?

28:42.770 --> 28:43.410
Niemand Vorschläge?

28:45.430 --> 28:46.010
Nicht viel.

28:46.410 --> 28:47.030
Ja bitte, da oben.

28:49.070 --> 28:51.190
Ja, Klebeband und Schläuche sind schon mal gut.

28:51.290 --> 28:52.130
Genau das hat man gemacht.

28:52.970 --> 28:56.290
Lustigerweise auch noch Tüten und auch eine Socke sind wohl zum

28:56.290 --> 28:56.930
Einsatz gekommen.

28:58.090 --> 29:00.790
Und damit hat man dann mal angefangen zu bauen.

29:02.090 --> 29:07.250
Und damit konnte man dann mehr oder weniger erfolgreich dieses Modul

29:07.250 --> 29:13.070
aus dem Kommandomodul mit dem in dem Mondlandemodul verbinden.

29:13.990 --> 29:16.130
Das sah dann ungefähr so aus.

29:17.590 --> 29:19.630
MacGyver hätte es nicht besser machen können, falls noch jemand

29:19.630 --> 29:20.250
MacGyver kennt.

29:21.450 --> 29:23.490
Auf jeden Fall sehen Sie hier genau das Problem.

29:24.830 --> 29:27.070
Wir hatten hier einen, kommt es noch?

29:27.290 --> 29:27.790
Ja, genau.

29:28.090 --> 29:33.750
Wir haben eine quadratische Verbindung im Mond, im Kommandomodul und

29:33.750 --> 29:35.610
im Mondlandemodul war die Verbindung rund.

29:35.710 --> 29:38.810
Das heißt, man musste da sehen, wie kommt man jetzt von dem einen zum

29:38.810 --> 29:39.030
anderen?

29:39.130 --> 29:44.790
Und dann hat man sich halt beholfen, indem man da mit Klebeband und

29:44.790 --> 29:49.230
viel, viel Spucke das irgendwie hinbekommen hat.

29:51.390 --> 29:54.870
So, jetzt die Frage, was ist die Lehre daraus?

29:56.870 --> 30:02.250
Lehre Nummer eins, sowas sehen Sie wahrscheinlich nicht nur in

30:02.250 --> 30:04.570
Mondlandefären, sowas sehen Sie auch im Code.

30:05.490 --> 30:09.450
Auch dort werden Sie Dinge haben, die nicht zueinander passen, obwohl

30:09.450 --> 30:11.610
Sie denken, das müsste doch jetzt eigentlich gehen.

30:11.610 --> 30:14.910
Der macht das, was ich haben will, nämlich in dem Fall Atemluft

30:14.910 --> 30:18.730
säubern und ich kann das ja wohl auch irgendwie nutzen können.

30:19.690 --> 30:24.770
Das heißt, auch dort werden Sie häufiger mal Adapter bauen müssen, von

30:24.770 --> 30:26.090
Ihrem Code zu anderem Code.

30:27.490 --> 30:30.310
Das ist auch gleich das erste Entwurfsmuster, was wir uns anschauen,

30:30.710 --> 30:32.230
ohne da jetzt zu viel zu verraten.

30:32.410 --> 30:36.830
Und das andere ist, hätte man das mal richtig gebaut, dann hätte man

30:36.830 --> 30:38.230
sich den ganzen Spaß ja sparen können.

30:38.710 --> 30:43.270
Hätte man hier mal ein Entwurfsmuster benutzt, um die Module zu bauen,

30:43.870 --> 30:45.210
dann hätte man die vielleicht gleich gebaut.

30:46.070 --> 30:49.870
Das heißt, bauen Sie Ihren Code sinnvoll, benutzen Sie Entwurfsmuster,

30:49.990 --> 30:52.150
dann kommen Sie vielleicht gar nicht in die Gelegenheit, sowas tun zu

30:52.150 --> 30:52.350
müssen.

30:54.870 --> 30:58.170
So, zurück zum eigentlichen Thema, nachdem Sie jetzt alle wach sind

30:58.170 --> 31:00.330
und hoffentlich dabei, die Entwurfsmuster.

31:01.050 --> 31:05.770
Es gibt unterschiedliche Kategorien von Entwurfsmustern, die Sie heute

31:05.770 --> 31:09.530
teilweise kennenlernen werden, dann aber auch nächste Woche wieder bei

31:09.530 --> 31:10.250
Professor Tichy.

31:11.410 --> 31:15.430
Die erste Kategorie sind die Entkopplungsmuster.

31:16.950 --> 31:21.570
Entkopplungsmuster haben zum Ziel, die einzelnen Teile Ihres Codes

31:21.570 --> 31:25.630
möglichst zu entkoppeln, möglichst wenig Abhängigkeiten, möglichst

31:25.630 --> 31:27.050
wenig Kopplung zu erzeugen.

31:27.550 --> 31:30.470
Sie erinnern sich vielleicht an das Geheimnis und an das

31:30.470 --> 31:31.470
Kapselungsprinzip.

31:32.750 --> 31:36.330
Die Entkopplungsmuster haben das Ziel, diese möglichst gut umzusetzen.

31:38.590 --> 31:42.870
Normalerweise oder häufig haben Entkopplungsmuster ein sogenanntes

31:42.870 --> 31:43.570
Kopplungsglied.

31:44.370 --> 31:49.730
Das sind dann bestimmte Interfaces oder Klassen, die die

31:49.730 --> 31:53.150
unterschiedlichen Einheiten, die man miteinander koppeln möchte, dann

31:53.150 --> 31:54.250
tatsächlich koppeln.

31:54.370 --> 31:57.310
Das heißt, dieses Kopplungsglied stellt die Verbindung zwischen den

31:57.310 --> 32:01.370
zwei zu koppelnden Einheiten dar oder stellt die Verbindung her.

32:02.790 --> 32:06.090
Das hat den Vorteil, dass Sie sich bloß im Kopplungsglied um die

32:06.090 --> 32:09.870
Kopplung tatsächlich kümmern müssen, hoffentlich, und Ihre beiden

32:09.870 --> 32:12.050
anderen Seiten nichts damit zu tun haben.

32:13.230 --> 32:15.650
Was sind so typische Entkopplungsmuster?

32:15.790 --> 32:18.910
Das ist zum einen der Adapter, den Sie gleich kennenlernen werden.

32:19.210 --> 32:22.110
Der sieht ein bisschen anders aus als damals bei Apollo 13, aber doch

32:22.110 --> 32:22.490
sehr ähnlich.

32:23.710 --> 32:26.390
Wir haben den Beobachter, den ich auch schon ein paar Mal genannt

32:26.390 --> 32:26.730
habe.

32:27.450 --> 32:28.270
Es gibt eine Brücke.

32:28.790 --> 32:29.870
Mal sehen, ob wir da heute noch hinkommen.

32:29.870 --> 32:30.870
Die sieht auch ganz nett aus.

32:31.430 --> 32:34.190
Es gibt Iterator, Stellvertreter und Vermittler.

32:37.070 --> 32:39.770
Dann als nächstes haben wir die Variantenmuster.

32:40.030 --> 32:46.230
Die kommen immer dann zum Einsatz, wenn ich in meiner Software gewisse

32:46.230 --> 32:50.450
Varianten von einer Klasse zum Beispiel herstellen möchte und das

32:50.450 --> 32:54.890
nicht immer jeweils wieder einzeln bauen möchte, sondern einfach die

32:54.890 --> 33:00.570
Gemeinsamkeiten dieser Varianten herausziehen können möchte, sodass

33:00.570 --> 33:04.090
ich dann bei der Erstellung und beim Entwurf weniger Probleme habe.

33:05.570 --> 33:08.630
Damit sparen Sie sich im Allgemeinen viel Code-Wiederholung.

33:09.550 --> 33:11.250
Sie steigern die Benutzbarkeit.

33:12.430 --> 33:15.810
Und Sie müssen sich häufig auch gar keine Gedanken mehr darüber

33:15.810 --> 33:19.570
machen, welche Variante jetzt wie hergestellt wird.

33:19.670 --> 33:22.830
Auch das ist ein Ziel der Variantenmuster.

33:24.210 --> 33:29.810
Die nächste Kategorie sind dann...

33:30.310 --> 33:34.210
der Besucher, der Erbauer, der allerdings für uns nicht relevant ist,

33:34.310 --> 33:37.950
die Fabrikmethode, das Kompositum, die Schablonenmethode, die

33:37.950 --> 33:40.550
Strategie und der Dekorierer.

33:43.070 --> 33:45.950
Ich merke schon, Ihr Interesse schwindet, weil ich nur aufzähle.

33:46.010 --> 33:48.230
Ich versuche das mal ein bisschen zu beschleunigen, damit wir dann zu

33:48.230 --> 33:49.570
den spannenden Dingen kommen.

33:51.030 --> 33:53.930
Die Zustandshandhabungsmuster, die machen das, was man sich vorstellt.

33:54.050 --> 33:57.530
Die halten einen Zustand oder sorgen dafür, dass ein gewisser Zustand,

33:57.530 --> 33:59.010
den ich haben möchte, hergestellt wird.

33:59.670 --> 34:03.290
Und dazu gehört das Einzelstück, das Fliegengewicht, Momento, Prototyp

34:03.290 --> 34:04.810
und Zustand, damit Sie es mal gehört haben.

34:06.050 --> 34:07.350
Kommt alles noch im Detail.

34:08.310 --> 34:10.770
Steuerungsmuster kümmern sich darum, dass mein Kontrollfluss im

34:10.770 --> 34:15.090
Programm den Ablauf nimmt, den ich denn gerne hätte.

34:15.730 --> 34:18.810
Mal so ein bisschen ab von dem üblichen, was man so kennt, Schleifen

34:18.810 --> 34:19.830
und Ifs und Else.

34:21.030 --> 34:23.370
Das heißt, dort kann man den Kontrollfluss steuern.

34:23.450 --> 34:27.030
Das ist zum einen das Befehlsentwurfsmuster und zum anderen, jetzt

34:27.030 --> 34:30.210
kommen wir schon langsam in die Richtung, was kann man auch in der

34:30.210 --> 34:32.870
Parallelität benutzen, die Sie später auch noch kennenlernen werden.

34:34.030 --> 34:39.770
In der Vorlesung das Master-Worker-Prinzip kann man auch benutzen, um

34:39.770 --> 34:41.850
den Kontrollfluss zu steuern.

34:42.930 --> 34:45.770
Die letzte Kategorie, die virtuellen Maschinen, die sind aber, wie Sie

34:45.770 --> 34:49.590
hier sehen, auch für uns in der Vorlesung nicht relevant, was eine

34:49.590 --> 34:51.830
virtuelle Maschine tut und macht.

34:51.930 --> 34:53.350
Davon gehe ich mal aus, dass Sie das wissen.

34:53.350 --> 35:00.190
Wir haben eine Schicht zwischen Software und Hardware normalerweise,

35:00.330 --> 35:06.030
die uns die Abstraktionen von der Hardware liefert, sodass wir unsere

35:06.030 --> 35:09.230
Software unabhängig von der Hardware bauen können.

35:10.630 --> 35:13.250
So viel an der Stelle dazu, denn wie Sie sehen, nicht

35:13.250 --> 35:13.850
prüfungsrelevant.

35:13.990 --> 35:16.250
Deshalb mache ich an der Stelle mal ein bisschen schneller weiter.

35:16.730 --> 35:18.390
Ach, die Bequemlichkeitsmuster, natürlich.

35:18.510 --> 35:19.950
Wie konnte ich meine Lieblingsmuster vergessen?

35:19.950 --> 35:24.530
Ich weiß nicht, wie es Ihnen geht, aber ich bin ganz gerne mal ein

35:24.530 --> 35:25.030
bisschen bequem.

35:25.590 --> 35:28.290
Und auch da helfen die Entwurfsmuster mitunter weiter.

35:30.290 --> 35:33.830
Wenn Sie gerne faul sind und sich ein bisschen Schreib- und Denkarbeit

35:33.830 --> 35:37.090
sparen wollen, dann benutzen Sie diese Entwurfsmuster.

35:37.210 --> 35:39.870
Das ist zum einen die Bequemlichkeitsklasse, die

35:39.870 --> 35:43.750
Bequemlichkeitsmethode, das vom Namen her schon sehr vielsagende

35:43.750 --> 35:44.270
Nullobjekt.

35:45.030 --> 35:48.910
Und zuletzt das wahrscheinlich sinnvollste in dieser Kategorie, die

35:48.910 --> 35:49.450
Fassade.

35:49.450 --> 35:53.750
Die werden Sie, denke ich mal, schon häufiger mal benutzen, vielleicht

35:53.750 --> 35:54.710
auch mal selber eine bauen.

35:57.690 --> 36:00.610
Gut, damit sind wir mit den Kategorien durch und können endlich wieder

36:00.610 --> 36:01.930
zu den spannenden Teilen kommen.

36:03.150 --> 36:05.910
Ich habe am Anfang schon mal gesagt, die Studenten sind häufig wenig

36:05.910 --> 36:09.050
begeistert von diesem Entwurfsmuster-Kapitel.

36:09.910 --> 36:13.350
Deshalb haben wir unsere Vorlesungen an der Stelle auch ein bisschen

36:13.350 --> 36:13.550
zusammengekürzt.

36:14.070 --> 36:15.510
Sie werden sehen, es ist trotzdem immer noch lang genug.

36:17.250 --> 36:21.150
Und zwar aus dem Grund, es gibt ein wirklich hervorragendes Buch über

36:21.150 --> 36:21.730
Entwurfsmuster.

36:21.850 --> 36:24.170
Und das ist nicht nur hervorragend, weil es inhaltlich hervorragend

36:24.170 --> 36:26.570
ist, es liest sich auch großartig.

36:27.230 --> 36:29.370
Und das ist dieses Head First Design Patterns.

36:31.310 --> 36:35.530
Auf Deutsch heißt das Entwurfsmuster von Kopf bis Fuß, glaube ich.

36:36.290 --> 36:38.810
Mein Tipp ist, wenn Sie es anfassen, lesen Sie es auf Englisch.

36:39.390 --> 36:41.370
Sie müssen sich irgendwann sowieso daran gewöhnen, Literatur auf

36:41.370 --> 36:41.970
Englisch zu lesen.

36:42.110 --> 36:43.350
Also machen Sie am besten gleich.

36:43.350 --> 36:47.150
Und mein Tipp ist auch, hier steht, lesen Sie Kapitel 12.

36:47.990 --> 36:48.590
Ich weiß nicht.

36:49.090 --> 36:52.270
Ja, da sind alle zusammen einmal vorgestellt, alle wichtigen

36:52.270 --> 36:52.870
Entwurfsmuster.

36:53.410 --> 36:55.530
Ich würde Ihnen empfehlen, lesen Sie das ganze Buch.

36:55.710 --> 36:58.390
Und das sage ich als jemand, der auch am KIT studiert hat.

36:58.470 --> 37:00.990
Und ich weiß, Sie haben viel, viel, viel zu tun.

37:01.310 --> 37:02.530
Aber das lohnt sich wirklich.

37:02.710 --> 37:03.850
Also das lohnt sich auch fürs Leben.

37:04.970 --> 37:08.270
Da lernt man wirklich gute, wichtige Dinge für den Entwurf und auch

37:08.270 --> 37:10.650
ansonsten für die Entwicklung kennen.

37:10.990 --> 37:11.450
Lesen Sie es.

37:12.630 --> 37:14.950
Dort gibt es, wie gesagt, das Kapitel 12.

37:15.450 --> 37:19.330
Und dort gibt es ein wunderbares Beispiel, die Entensimulation.

37:19.810 --> 37:22.010
Also ich weiß nicht, wen das jetzt nicht anspricht.

37:22.870 --> 37:26.190
Dort werden tatsächlich ein Zoo voll Enten simuliert.

37:26.570 --> 37:31.070
Und es werden dort unterschiedliche Entwurfsmuster tatsächlich

37:31.070 --> 37:31.610
verwendet.

37:32.250 --> 37:35.270
Das sind Adapter, Dekorierer, Abstrakt der Fabrik, Kompositum,

37:35.350 --> 37:36.330
Iterator und Beobachter.

37:36.830 --> 37:38.770
Und das ist auch genau der Grund, warum ich Ihnen sage, lesen Sie

37:38.770 --> 37:39.690
vielleicht das ganze Buch.

37:39.690 --> 37:43.290
Wenn Sie dort gleich anfangen, könnte es vielleicht vom Verständnis

37:43.290 --> 37:44.110
her etwas schwierig werden.

37:44.210 --> 37:48.490
Wenn Sie vorne anfangen, verspreche ich Ihnen, verstehen Sie alles bis

37:48.490 --> 37:48.870
zum Ende.

37:49.690 --> 37:53.250
Denn das Buch ist wirklich so geschrieben, dass man es gut verstehen

37:53.250 --> 37:53.510
kann.

37:53.670 --> 37:56.430
Es ist wirklich so geschrieben, dass man viel, viel lernt.

37:56.870 --> 37:59.270
Auch deshalb, weil immer wieder mal Fragen gestellt werden.

38:00.070 --> 38:02.850
Dinge nicht nur vorgestellt werden, sondern auch diskutiert werden.

38:03.390 --> 38:05.250
Es gibt kleine Aufgaben, die Sie lösen können.

38:05.430 --> 38:07.510
Also insofern sehr empfehlenswert.

38:08.270 --> 38:09.870
Gut, jetzt habe ich genug Werbung gemacht.

38:11.790 --> 38:13.890
Fangen wir jetzt mal an mit der ersten Kategorie, die

38:13.890 --> 38:14.650
Entkopplungsmuster.

38:15.650 --> 38:18.910
Und ich habe es jetzt schon ein paar Mal verraten und das einführende

38:18.910 --> 38:20.430
Beispiel war es ja auch.

38:20.710 --> 38:22.890
Der Adapter, mit dem fangen wir gleich mal an.

38:24.330 --> 38:28.830
Sie werden jetzt auf den nächsten Folien, überhaupt auf allen Folien

38:28.830 --> 38:32.010
zu den Entwurfsmustern, immer wieder dieses Schema sehen, dass Sie

38:32.010 --> 38:33.910
zunächst einmal einen Zweck sehen.

38:34.750 --> 38:36.290
Wofür ist das Entwurfsmuster gut?

38:36.290 --> 38:38.790
Und das hängt damit zusammen, dass ich Ihnen am Anfang gesagt habe,

38:38.870 --> 38:42.950
Sie müssen ein Entwurfsmuster immer begreifen als ein Tupel von

38:42.950 --> 38:44.770
Problemen und Lösungen.

38:45.010 --> 38:47.530
Das heißt, wir fangen hier mit der Problemstellung immer an und zeigen

38:47.530 --> 38:49.130
Ihnen dann die Lösung.

38:50.650 --> 38:54.630
Beim Adapter ist es so, wir haben zwei Schnittstellen und die passen

38:54.630 --> 38:55.410
irgendwie nicht zusammen.

38:56.290 --> 39:00.750
So wie vorhin in der Apollo 13 Mission auch.

39:01.210 --> 39:02.910
Sie können sich das aber auch einfacher vorstellen.

39:02.910 --> 39:05.990
Packen Sie mal Ihren Föhn ein und fliegen nach Amerika und dann

39:05.990 --> 39:07.730
versuchen Sie mal dort eine Steckdose zu benutzen.

39:08.150 --> 39:09.750
Dann stehen Sie vor einem ähnlichen Problem.

39:10.890 --> 39:13.950
Ein kleiner Tipp, versuchen Sie es dann nicht mit Klebeband oder Draht

39:13.950 --> 39:16.170
oder Ähnlichem, sondern benutzen Sie einen Adapter.

39:17.650 --> 39:19.850
Der leistet Ihnen nämlich genau das, was Sie wollen.

39:20.550 --> 39:24.170
Der überführt die eine Schnittstelle in die andere.

39:24.630 --> 39:25.670
Und das ist ja genau das, was wir wollen.

39:25.870 --> 39:29.850
Offensichtlich haben wir auf der einen Seite jemanden, der eine

39:29.850 --> 39:32.050
gewisse Funktionalität haben möchte, in dem Fall ihr Föhn.

39:32.710 --> 39:34.270
Und auf der anderen Seite haben wir die Steckdose.

39:34.370 --> 39:36.910
Die kann offensichtlich das liefern, was der Föhn braucht, nämlich

39:36.910 --> 39:37.230
Strom.

39:37.790 --> 39:39.910
Trotzdem finden die nicht zusammen, weil die Schnittstellen nicht

39:39.910 --> 39:40.210
passen.

39:40.750 --> 39:42.550
Und genau das leisten Adapter.

39:46.130 --> 39:49.530
Da Entwurfsmuster häufig benutzt werden, haben die häufig auch

39:49.530 --> 39:49.930
Synonyme.

39:49.990 --> 39:51.790
Die stehen dann immer hier unten auf unseren Folien.

39:51.870 --> 39:54.210
Hier ist es der Wandler, der Umwickler oder English Rapper.

39:55.950 --> 39:57.590
Nur, damit Sie das auch mal gehört haben.

39:57.690 --> 40:01.210
Falls mal dann im Gespräch mit Ihrem Chef oder mit Ihrem Kollegen

40:01.210 --> 40:04.750
jemand plötzlich von einem Rapper spricht, dann wissen Sie, der meint

40:04.750 --> 40:05.050
Adapter.

40:06.570 --> 40:08.050
Wie sieht jetzt so ein Adapter aus?

40:09.410 --> 40:16.390
Wir haben hier unsere Zielschnittstelle, die wir benutzen wollen als

40:16.390 --> 40:17.990
Klient, als Klientprogramm.

40:19.590 --> 40:23.270
Und wir haben auf der anderen Seite die Operation, die uns das

40:23.270 --> 40:24.810
liefert, was wir haben wollen.

40:25.470 --> 40:26.950
Das könnte also unsere Steckdose sein.

40:27.250 --> 40:29.850
Aber wir kommen da nicht hin, weil offensichtlich kennen wir diese

40:29.850 --> 40:30.550
Operation nicht.

40:31.470 --> 40:34.330
Und aus irgendwelchen Gründen können Sie diese Klasse nicht ändern.

40:34.490 --> 40:37.170
Ein typisches Beispiel ist, dass da drüben ist eine Bibliothek.

40:37.670 --> 40:39.610
Die können Sie häufig nicht ändern.

40:40.990 --> 40:46.810
Und auf der Seite können oder wollen oder dürfen Sie die Schnittstelle

40:46.810 --> 40:47.890
auch nicht ändern.

40:48.490 --> 40:52.510
Manchmal liegt es auch einfach nur daran, dass man die Schnittstelle

40:52.510 --> 40:54.130
einmal definiert hat und nicht mehr ändern möchte.

40:54.350 --> 40:58.490
Dass man die Operation, die dort steht, häufig benutzt hat und nicht

40:58.490 --> 41:00.050
seinen ganzen Quelltext umschreiben möchte.

41:01.550 --> 41:04.630
Und dann baut man an dieser Stelle einen Adapter.

41:04.630 --> 41:10.210
Dieser Adapter implementiert einfach die Schnittstelle, die Sie

41:10.210 --> 41:10.890
benutzen möchten.

41:12.950 --> 41:17.670
Und im Bauch des Adapters wird dann eben genau die Verbindung zu der

41:17.670 --> 41:18.910
adaptierten Klasse hergestellt.

41:19.210 --> 41:26.310
In dem Fall ganz einfach, indem dieses adaptierte Objekt, dort wird

41:26.310 --> 41:29.750
dann diese spezifische Operation in dieser Operationsmethode

41:29.750 --> 41:30.330
aufgerufen.

41:30.890 --> 41:31.490
So einfach.

41:31.630 --> 41:33.150
Und schon haben Sie eine Verbindung geschaffen.

41:34.610 --> 41:38.490
Von Ihrer eigentlichen Zielschnittstelle zu dieser Klasse, die Sie

41:38.490 --> 41:39.970
gerne benutzen möchten.

41:41.070 --> 41:43.410
Klingt einfach, das geht natürlich auch noch deutlich komplizierter.

41:43.770 --> 41:46.430
Und ich werde Ihnen versprechen, Sie werden das brauchen.

41:48.130 --> 41:50.910
Vom Adapter gibt es auch noch eine andere Variante.

41:52.410 --> 41:55.370
Das ist der sogenannte Klassenadapter.

41:57.910 --> 42:01.850
Dort erben wir sowohl von der Zielschnittstelle oder von der

42:01.850 --> 42:02.370
Zielklasse.

42:02.370 --> 42:03.990
Das kann in dem Fall dann auch eine Klasse sein.

42:05.390 --> 42:07.030
Und der adaptierten Klasse.

42:08.770 --> 42:11.470
Und haben dann auch ein Adapter durch Mehrfachvererbung.

42:13.350 --> 42:14.590
Jetzt wieder zum Wachwerden.

42:14.670 --> 42:15.350
Was ist das Problem?

42:15.990 --> 42:19.370
Wenn Sie diesen Adapter in Java bauen wollen...

42:20.390 --> 42:21.370
Sie waren halt schon die ganze Zeit...

42:21.910 --> 42:22.490
Ach nee, nur einmal.

42:22.670 --> 42:23.490
Ja, da jemand Neues.

42:25.650 --> 42:29.330
Genau, in Java können wir keine Mehrfachvererbung benutzen, die ist

42:29.330 --> 42:30.010
einfach nicht erlaubt.

42:30.610 --> 42:32.930
In dem Fall würde es sogar gehen, weil es nur eine Schnittstelle ist.

42:33.070 --> 42:36.650
Aber Sie haben recht, Mehrfachvererbung geht in Java nicht.

42:37.130 --> 42:40.190
Das heißt, Sie können natürlich im Modell immer viel hin modellieren.

42:40.610 --> 42:44.030
Ob Sie das benutzen können in Java, ist dann immer die nächste Frage.

42:44.210 --> 42:47.210
Aber es kann ja auch sein, dass Ihr Entwurf tatsächlich für eine

42:47.210 --> 42:49.810
andere Programmiersprache später zur Umsetzung mal gedacht ist.

42:50.370 --> 42:54.170
Also Entwurf und tatsächliche Umsetzung in der Programmiersprache sind

42:54.170 --> 42:54.870
nicht das Gleiche.

42:54.870 --> 42:58.810
Sie müssen sich im Entwurf noch nicht Gedanken darüber machen, wie und

42:58.810 --> 43:00.010
ob das umsetzbar ist.

43:00.910 --> 43:02.610
Das vielleicht nur mal so am Rande.

43:03.450 --> 43:05.310
Das funktioniert aber an sich ähnlich.

43:06.810 --> 43:09.410
So, hier haben wir ein Beispiel.

43:10.850 --> 43:15.670
Wir haben ein Feld, in dem stehen irgendwelche Elemente drin.

43:15.790 --> 43:17.190
Und mit dem wollen wir jetzt was machen.

43:17.310 --> 43:20.510
In dem Fall wollen wir zwei Elemente aus diesem Feld vielleicht

43:20.510 --> 43:21.090
vergleichen.

43:21.090 --> 43:26.110
Und haben deshalb diese Vergleicherschnittstelle, der man zwei

43:26.110 --> 43:30.090
Elemente aus diesem Feld übergibt.

43:30.190 --> 43:32.510
Und die werden dann verglichen und dann heißt es größer, kleiner,

43:32.630 --> 43:32.850
gleich.

43:33.910 --> 43:39.130
Problem ist, die Klasse, die uns diese Funktionalität bietet, die hat

43:39.130 --> 43:41.330
komischerweise andere Methoden.

43:41.510 --> 43:44.570
Die tun das Gleiche, die machen nämlich auch ein größer, größer als

43:44.570 --> 43:46.150
und die machen auch ein gleich.

43:46.830 --> 43:48.330
Aber es ist halt anders hingeschrieben.

43:49.510 --> 43:55.830
Was Sie dann tun müssen, ist Ihren Vergleicher implementieren.

43:56.310 --> 43:58.950
Und dann haben Sie hier diese Vergleichemethode, die Sie

43:58.950 --> 43:59.950
implementieren müssen.

44:00.310 --> 44:04.690
Und dort rufen Sie einfach in geeigneter Weise das Größer als und das

44:04.690 --> 44:05.650
Gleich auf.

44:07.490 --> 44:10.950
Einfaches Beispiel zugegeben, wenn Sie ein etwas komplexeres Beispiel

44:10.950 --> 44:11.510
sehen wollen.

44:11.910 --> 44:13.610
Schauen Sie wieder in Headfirst Design Patterns.

44:13.610 --> 44:16.990
Da sind tatsächlich gute Beispiele, die das noch ein Tick besser

44:16.990 --> 44:19.970
motivieren, warum man das tatsächlich häufig braucht.

44:21.170 --> 44:25.870
Hier ist nochmal zusammengefasst, warum man das denn benutzen möchte.

44:25.990 --> 44:28.410
Das ist, glaube ich, ungefähr so das, was ich schon gesagt habe.

44:29.150 --> 44:32.430
Wir haben existierende Klassen, deren Schnittstellen wir nicht

44:32.430 --> 44:36.710
verändern können, wollen, dürfen, müssen, wie auch immer.

44:38.810 --> 44:44.130
Und ja, das andere sind eher so nachgelagerte Fälle, die aber im

44:44.130 --> 44:46.950
Grunde alle genau darauf hinauslaufen.

44:48.490 --> 44:52.190
Gut, dann sind wir mit dem Adapter sogar schon durch.

44:52.510 --> 44:54.150
Hat jemand Fragen bis hierher?

45:03.400 --> 45:05.660
Dann warte ich noch kurz, bis sich hier Kommilitone wieder gesetzt

45:05.660 --> 45:05.880
hat.

45:07.320 --> 45:09.420
Gemein, wenn er extra genannt wird.

45:09.420 --> 45:13.720
Okay, dann machen wir weiter mit dem nächsten Entwurfsmuster, der

45:13.720 --> 45:14.300
Beobachter.

45:14.400 --> 45:20.180
Den habe ich ja schon häufiger genannt und ich wette, jeder von Ihnen

45:20.180 --> 45:22.740
hat das auch schon mal gesehen, einen Beobachter.

45:23.260 --> 45:23.480
Wo?

45:24.160 --> 45:24.760
Sehen wir gleich.

45:26.380 --> 45:28.960
Zunächst einmal, wofür ist der Beobachter da?

45:28.960 --> 45:35.540
Den Beobachter setzen wir dann ein, wenn wir eine 1 zu N Abhängigkeit

45:35.540 --> 45:40.100
haben zwischen einem Subjekt und anderen sogenannten Beobachtern, die

45:40.100 --> 45:41.840
etwas wissen wollen über das Subjekt.

45:43.240 --> 45:47.260
Das heißt also, unser Subjekt hat irgendeinen Zustand und der Zustand,

45:47.380 --> 45:48.680
der kann sich ändern.

45:49.240 --> 45:52.800
Und wenn sich der Zustand unseres Subjekts ändert, dann möchten

45:52.800 --> 45:57.540
diejenigen, die dieses Subjekt beobachten, diese Änderung gerne

45:57.540 --> 45:58.620
mitbekommen.

46:02.240 --> 46:05.280
Das ist natürlich, ja, da können wir natürlich jetzt sagen, ja, dann

46:05.280 --> 46:06.520
schicken wir doch einfach die Nachricht an die.

46:07.240 --> 46:09.800
Ja, das könnte man natürlich tun, aber Sie merken schon, dann haben

46:09.800 --> 46:11.440
wir wieder eine starke Kopplung.

46:11.840 --> 46:13.500
Dann müssten wir alle unsere Beobachter kennen.

46:13.880 --> 46:14.700
Das wollen wir nicht haben.

46:15.340 --> 46:16.900
Deshalb müssen wir das ein bisschen schlauer machen.

46:16.900 --> 46:18.000
Wie wir das machen, sehen wir gleich.

46:18.540 --> 46:21.900
Vorher erstmal wieder die, die bekannten Synonyme.

46:22.980 --> 46:24.540
Abhängigkeit, ja, nicht so viel sagen.

46:24.820 --> 46:26.340
Publizieren, abonnieren, das ist ganz hübsch.

46:26.420 --> 46:29.880
Da kann man schöne Beispiele mit Zeitungen, die publiziert werden und

46:29.880 --> 46:30.520
Abonnenten bauen.

46:31.020 --> 46:32.400
Vielleicht mache ich das gleich auch noch, mal schauen.

46:32.580 --> 46:33.620
Vielleicht fällt mir auch etwas anderes ein.

46:34.160 --> 46:36.520
Und Subjekt, Beobachter, das ist das, was ich gerade eben schon

46:36.520 --> 46:37.080
benutzt habe.

46:37.160 --> 46:42.520
Ganz einfach, weil beobachtetes Objekt und beobachtende Objekte auf

46:42.520 --> 46:44.160
Dauer einen Knoten in die Zunge machen.

46:44.240 --> 46:45.900
Deshalb bleibe ich bei Subjekt und Beobachter.

46:47.580 --> 46:53.460
Und hier sehen Sie, wofür das denn überhaupt sinnvoll ist.

46:55.140 --> 47:03.780
Wir wollen, dass Objekte, die ein Subjekt beobachten, wissen, was da

47:03.780 --> 47:04.280
passiert.

47:04.400 --> 47:08.460
Das heißt, wir wollen dort konsistente Informationsweitergabe oder

47:08.460 --> 47:12.140
konsistentes Wissen über den Zustand des beobachteten Subjekts.

47:14.040 --> 47:17.320
Das Ganze wollen wir, wie ich gerade eben schon gesagt habe, nicht eng

47:17.320 --> 47:17.680
koppeln.

47:18.040 --> 47:23.640
Das ist immer eine blöde Idee, weil wir dann sowohl das Subjekt als

47:23.640 --> 47:26.320
auch die Beobachter ganz schlecht wiederverwenden können.

47:27.200 --> 47:30.840
Wenn zum Beispiel ein Beobachter wegfällt plötzlich, dann müssen Sie

47:30.840 --> 47:35.840
tatsächlich den Code Ihres Subjektes, das den Zustand trägt, anfassen.

47:35.960 --> 47:36.980
Und das wollen Sie nicht.

47:37.540 --> 47:42.640
Genauso auf der anderen Seite, wenn Sie der Beobachter sind und ein

47:42.640 --> 47:46.380
Subjekt beobachten, dann wollen Sie auch möglichst wenig ändern, wenn

47:46.380 --> 47:47.960
Sie plötzlich ein anderes Subjekt beobachten.

47:48.520 --> 47:51.740
Also ich glaube, es ist relativ einleuchtend, dass man hier eine lose

47:51.740 --> 47:53.020
Kopplung haben möchte.

47:56.420 --> 47:58.220
Hier unten steht noch was von einem MVC-Beispiel.

47:58.340 --> 47:59.540
Ich hoffe, das haben Sie am Montag gemacht.

48:01.260 --> 48:02.880
Das kommt aber, glaube ich, auch nochmal.

48:03.020 --> 48:05.560
Deshalb lasse ich das jetzt an der Stelle weg, weil wir das gleich

48:05.560 --> 48:06.120
noch sehen werden.

48:06.120 --> 48:09.260
Und gehe gleich mal zum Klassendiagramm über.

48:10.020 --> 48:13.340
Bitte nicht erschlagen fühlen von den Klassendiagrammen, die auch

48:13.340 --> 48:17.440
etwas größer werden können bei den Entwurfsmustern.

48:17.720 --> 48:21.460
Versuchen Sie immer zu verstehen, was wir denn tun, was wir denn

48:21.460 --> 48:22.100
erreichen wollen.

48:23.480 --> 48:27.780
Was wir tun wollen ist, wir haben auf der einen Seite ein Subjekt und

48:27.780 --> 48:28.940
auf der anderen Seite Beobachter.

48:29.120 --> 48:31.980
Und wir wollen, dass dieser Zustand irgendwie dahin kommt.

48:32.040 --> 48:33.020
Der soll publiziert werden.

48:34.240 --> 48:38.880
Dafür benutzen wir jetzt auf der einen Seite, in dem Fall ist es hier

48:38.880 --> 48:40.180
eine Klasse.

48:40.260 --> 48:44.200
Man könnte das aber auch als Schnittstelle bauen oder auch als

48:44.200 --> 48:45.880
abstrakte Klasse.

48:46.000 --> 48:47.980
Und hier sehen Sie schon Familie von Lösungen.

48:48.080 --> 48:50.120
Das kann man auch alles ein bisschen anders bauen.

48:50.560 --> 48:51.360
Passen Sie sich das an.

48:51.820 --> 48:54.920
Wir haben ein Subjekt und das wird beobachtet von Beobachtern.

48:57.180 --> 49:01.300
Diese Beobachter haben eine aktualisierende Methode.

49:01.880 --> 49:06.360
Die ist dafür da, dass sie den aktuellen Zustand oder dass sie die

49:06.360 --> 49:10.600
Informationen darüber bekommen, wenn sich hier im Subjekt etwas

49:10.600 --> 49:11.220
geändert hat.

49:11.880 --> 49:16.760
Das Subjekt wiederum muss mindestens die Methoden anbieten zum

49:16.760 --> 49:20.160
Anmelden von Beobachtern, sodass sich diese Beobachter beim Subjekt

49:20.160 --> 49:23.660
anmelden können und auch wieder abmelden können, damit das Subjekt

49:23.660 --> 49:27.860
weiß, wie viele Beobachter und welche Beobachter habe ich denn im

49:27.860 --> 49:28.100
Moment.

49:30.100 --> 49:33.980
Und wir brauchen eine benachrichtigende Methode, die eben genau das

49:33.980 --> 49:38.260
leistet, nämlich die Beobachter benachrichtigen.

49:39.560 --> 49:42.640
Wenn ich meinen Zustand ändere und das ist jetzt das konkrete Subjekt,

49:42.880 --> 49:47.820
also wir implementieren die Schnittstelle oder wir erben von der

49:47.820 --> 49:52.960
abstrakten Klasse Subjekt und dort haben wir jetzt einen Zustand in

49:52.960 --> 49:53.500
unserem Subjekt.

49:53.620 --> 50:02.220
Und wenn sich der ändert, dann rufe ich diese aktualisierende Methode

50:02.220 --> 50:02.740
auf.

50:03.400 --> 50:08.680
Und dann wissen die Beobachter, dass sich wohl irgendwas im Subjekt

50:08.680 --> 50:09.800
geändert hat.

50:10.860 --> 50:14.000
Und wenn sich irgendwas geändert hat im Subjekt, also diese

50:14.000 --> 50:18.460
aktualisierende Methode im konkreten Beobachter aufgerufen wurde, dann

50:18.460 --> 50:19.940
hole ich mir den Zustand, den neuen.

50:20.160 --> 50:23.540
Dann weiß ich, jetzt hat sich was geändert und jetzt hole ich mir aus

50:23.540 --> 50:27.960
dem Subjekt mit dieser Gibt-Zustand-Methode den aktuellen Zustand des

50:27.960 --> 50:28.440
Subjektes.

50:30.820 --> 50:32.080
So, das war jetzt sehr viel auf einmal.

50:32.320 --> 50:33.560
Klar soweit, gibt es Fragen?

50:38.770 --> 50:43.290
Genau, hier sehen Sie das nochmal als Diagramm, was da passiert.

50:43.690 --> 50:50.790
Wir haben das konkrete Subjekt, das Benachrichtige aufruft und damit

50:50.790 --> 50:53.950
dann das Aktualisiere im konkreten Beobachter.

50:56.430 --> 51:00.830
Und die konkreten Beobachter holen sich dann den Zustand aus dem

51:00.830 --> 51:01.750
konkreten Subjekt.

51:02.150 --> 51:05.450
Und so kann das dann auch noch mit einem weiteren konkreten Beobachter

51:05.450 --> 51:06.390
passieren.

51:07.890 --> 51:10.670
Ja, das ist im Grunde das, wie das dann abläuft.

51:11.050 --> 51:13.370
Ich glaube, das ist auch an der Stelle gar nicht so furchtbar

51:13.370 --> 51:13.630
interessant.

51:13.770 --> 51:16.610
Deshalb mache ich jetzt weiter mit dem tatsächlichen Beispiel, was ich

51:16.610 --> 51:17.510
Ihnen schon versprochen hatte.

51:17.510 --> 51:23.890
Wir haben als Subjekt in diesem Beispiel, sagen wir mal Tabellen,

51:24.230 --> 51:24.550
Daten.

51:26.530 --> 51:31.870
Und dieses Datenobjekt, Datensubjekt, das kann sich ja ändern.

51:32.050 --> 51:37.390
Ich ändere Daten in meiner Tabelle, füge eine Zeile hinzu oder was

51:37.390 --> 51:37.730
auch immer.

51:38.250 --> 51:42.390
Und dann habe ich hier oben ganz viele Beobachter, die die Daten

51:42.390 --> 51:42.990
darstellen.

51:43.630 --> 51:47.710
Wir haben ein Fenster, was einfach nur die Tabelle darstellt.

51:47.810 --> 51:53.810
Wir haben ein Fenster, was einfach nur ein Säulendiagramm darstellt.

51:53.890 --> 51:56.030
Und wir haben hier dieses Pie Chart auf der rechten Seite.

51:56.750 --> 52:00.230
Und die möchten natürlich alle über die Änderungen Bescheid wissen,

52:00.350 --> 52:02.550
die hier unten im Subjekt passieren.

52:02.550 --> 52:09.210
Und genau für solche Situationen ist dieses spezielle Entwurfsmuster,

52:09.250 --> 52:11.850
das Beobachterentwurfsmuster hilfreich.

52:13.870 --> 52:16.630
So, wann können wir das anwenden?

52:16.750 --> 52:18.930
Ich glaube, das wurde jetzt auch schon gesagt.

52:19.010 --> 52:20.810
Steht da noch irgendwas Neues, was ich nicht gesagt habe?

52:23.790 --> 52:27.130
Ja, der erste Punkt ist vielleicht noch ganz interessant.

52:31.290 --> 52:35.530
Als Subjekt, das beobachtet wird, wollen sie nicht wissen, wie viele

52:35.530 --> 52:37.470
Beobachter sie tatsächlich haben.

52:38.530 --> 52:41.890
Sie wollen einfach nur einen Zustand haben und sie wollen Beobachter

52:41.890 --> 52:44.490
benachrichtigen können.

52:44.910 --> 52:47.850
Mehr wollen sie nicht wissen von diesen Beobachtern.

52:49.890 --> 52:53.610
Genauso auf der anderen Seite, sie wollen als Beobachter

52:53.610 --> 52:54.750
benachrichtigt werden.

52:54.750 --> 52:58.070
Sie wollen aber keine Annahmen treffen müssen über die interne

52:58.070 --> 53:00.350
Struktur des Subjektes, das sie da beobachten.

53:00.430 --> 53:02.810
Sie wollen einfach nur den Zustand, sie wollen einfach nur wissen, was

53:02.810 --> 53:03.330
passiert da.

53:04.710 --> 53:13.530
Genau, Kapselung, habe ich schon gesagt, oder dieses Entwurfsmuster

53:13.530 --> 53:18.390
hilft, um die Kapselung möglichst weit auszuprägen und dadurch

53:18.390 --> 53:20.650
natürlich die Wiederverwendbarkeit.

53:20.650 --> 53:23.910
Was hat das jetzt für Konsequenzen?

53:24.510 --> 53:28.210
Wir können unabhängig die Subjekte und Beobachter wiederverwenden, das

53:28.210 --> 53:28.970
ist glaube ich auch klar.

53:29.350 --> 53:35.310
Beobachter können hinzugefügt werden, dynamisch sage ich jetzt mal,

53:35.750 --> 53:39.130
dynamisch hinzugefügt werden und entfernt werden und das vor allem

53:39.130 --> 53:41.630
ohne, dass sich das Subjekt verändern muss.

53:41.730 --> 53:43.770
Ich muss mich da nicht drum kümmern, das funktioniert einfach.

53:48.410 --> 53:50.450
Die Informationsweitergabe funktioniert über diese Benachrichtigung,

53:50.550 --> 53:52.690
das haben wir jetzt auch schon häufiger gehört.

53:56.050 --> 54:01.230
Und wir sind uns sicher, dass bei dieser Nachrichtenweitergabe keine

54:01.230 --> 54:02.010
Zyklen entstehen.

54:02.130 --> 54:04.330
Das ist auch hilfreich, wir wissen, die Nachricht wird weitergegeben

54:04.330 --> 54:05.210
und dann ist sie da.

54:09.110 --> 54:11.710
Rundruf von Änderungen ist auch klar, wir haben diese vielen

54:11.710 --> 54:13.870
Abonnenten an dem Subjekt.

54:15.130 --> 54:17.430
Stellen Sie sich vor, Sie sind Zeitungsverleger, jetzt bringe ich doch

54:17.430 --> 54:21.870
das Beispiel, und sagen, okay, ich habe eine neue Zeitung

54:21.870 --> 54:26.830
rausgebracht, dann ist genau diese Information von mir aus Plakatwände

54:26.830 --> 54:29.930
oder was auch immer, diese aktualisierende Methode.

54:29.930 --> 54:34.410
Und dann können Ihre Abonnenten selber entscheiden, okay, ich gehe

54:34.410 --> 54:36.490
jetzt zum Kiosk und hole mir die aktuelle Zeitung.

54:39.050 --> 54:43.530
Das ist auch noch ein ganz wichtiger Punkt, Sie bekommen auch in Ihren

54:43.530 --> 54:48.430
Beobachtern die Freiheit, diese Informationen, diesen aktuellen neuen

54:48.430 --> 54:49.690
Zustand einfach zu ignorieren.

54:50.430 --> 54:52.810
Wenn Sie sagen, ich habe gerade andere Dinge zu tun oder ich brauche

54:52.810 --> 54:55.610
die aktuelle Zeitung gerade nicht, dann können Sie das auch

54:55.610 --> 54:58.030
ignorieren, auch vielleicht abhängig von Ihrem eigenen Zustand.

54:58.610 --> 55:03.670
Das ist auch noch ein großer Vorteil dieses Entwurfsmusters und dem

55:03.670 --> 55:06.230
Fakt, dass wir diese sehr lose Kopplung haben.

55:10.000 --> 55:15.540
Genau, das ist, glaube ich, auch weniger interessant, das haben wir

55:15.540 --> 55:18.480
schon am Klassendiagramm gezeigt.

55:20.400 --> 55:24.280
Ich glaube, auf der nächsten Folie kommt eher noch etwas

55:24.280 --> 55:25.140
Interessanteres.

55:30.980 --> 55:35.680
Es gibt bei der ganzen Sache noch so ein kleines

55:35.680 --> 55:38.280
Implementierungsproblemchen vielleicht.

55:38.660 --> 55:45.420
Wir müssen sicherstellen, dass unser Subjekt konsistent ist, wenn wir

55:45.420 --> 55:47.740
denn die benachrichtige Methode aufrufen.

55:47.840 --> 55:52.680
Das heißt, wir müssen sicherstellen, dass wenn dann die Beobachter

55:52.680 --> 55:55.720
kommen und sich den aktuellen Zustand abholen, dass sie auch alle den

55:55.720 --> 55:56.580
gleichen bekommen.

55:57.720 --> 55:59.200
Dafür müssen wir irgendwie sorgen.

56:01.020 --> 56:03.720
Das ist jetzt erstmal Ihnen überlassen.

56:04.120 --> 56:07.000
Es gibt aber auch dazu ein kleines Werkzeug, nämlich die

56:07.000 --> 56:07.920
Schablonmethode.

56:08.040 --> 56:11.240
Die werden Sie wahrscheinlich dann das nächste Mal kennenlernen.

56:11.340 --> 56:13.320
Die sorgt genau dafür, dass sowas nicht passiert.

56:15.000 --> 56:17.680
Und zuletzt noch eine andere Variante.

56:17.860 --> 56:20.120
Gehen wir mal wieder zurück zu der Zeitung.

56:20.840 --> 56:25.020
Vielleicht sind Sie ein Zeitungsabonnent oder Ihr Zeitungsverleger

56:25.020 --> 56:28.880
fährt diese Variante, dass Zeitungen nicht am Kiosk zu kaufen sind,

56:29.020 --> 56:32.020
sondern dass Sie die direkt in den Briefkasten bekommen.

56:33.180 --> 56:34.600
Das ist die zweite Variante.

56:34.720 --> 56:36.240
Das ist die Push-Variante.

56:36.380 --> 56:40.160
Was wir bisher gesehen haben, ist die Pull-Variante des

56:40.160 --> 56:41.000
Entwurfsmusters.

56:42.080 --> 56:45.200
Da bekommen wir als Beobachter nur die Information, hier hat sich was

56:45.200 --> 56:49.500
geändert, möchtest du einen neuen Zustand holen und dann entscheidet

56:49.500 --> 56:52.980
man als Beobachter selbst, okay, jetzt gehe ich los und hole mir den

56:52.980 --> 56:54.340
neuen Zustand aus dem Subjekt.

56:55.260 --> 56:58.920
Die andere Variante ist, dass diese Zustandsänderung einfach gleich

56:58.920 --> 56:59.600
mitgeschickt wird.

57:00.180 --> 57:03.100
Das heißt, wenn Sie morgens aus dem Haus laufen und im Briefkasten

57:03.100 --> 57:06.160
liegt die neue Zeitung, dann haben Sie die aktuelle Zeitung dann

57:06.160 --> 57:06.720
plötzlich schon.

57:07.100 --> 57:09.880
Und das ist genau diese Push-Variante.

57:11.660 --> 57:14.940
Was ist jetzt Vor- und Nachteil der jeweiligen Varianten?

57:16.820 --> 57:20.820
Diese Pull-Variante, die kann natürlich ineffizient sein.

57:21.760 --> 57:24.520
Wenn man jedes Mal dann extra die Daten wiederholen muss, weil man

57:24.520 --> 57:27.240
doch weiß, ich brauche die Daten eh, dann können die doch einfach

57:27.240 --> 57:28.200
gleich mitgeliefert werden.

57:29.240 --> 57:32.820
Dafür gibt es das Push-Modell, aber Sie merken schon, auch das kann

57:32.820 --> 57:36.100
natürlich ein Problem mit sich bringen, nämlich wenn ich doch

57:36.100 --> 57:38.200
plötzlich nicht immer den aktuellen Zustand brauche.

57:39.100 --> 57:45.720
Abgesehen davon erzeugen wir dadurch, dass wir den Zustand gleich

57:45.720 --> 57:48.420
mitschicken, wieder eine etwas stärkere Kopplung.

57:48.800 --> 57:52.080
Also das muss Ihnen bewusst sein, Sie haben dann wieder eine gewisse

57:52.080 --> 57:56.920
stärkere Kopplung einfach durch die Daten, die Sie übergeben, erzeugt

57:56.920 --> 57:59.460
und haben da im Grunde so ein bisschen die Stärken des Entwurfsmusters

57:59.460 --> 58:00.140
aufgeweicht.

58:00.220 --> 58:04.280
Aber trotzdem kann auch dieses Push-Modell interessant sein,

58:04.420 --> 58:09.960
insbesondere dann, wenn Sie wissen, okay, ich brauche jedes Mal im

58:09.960 --> 58:15.520
Beobachter oder in den beobachten Objekten die Zustandsänderung.

58:15.860 --> 58:17.120
Und da sehe ich eine Fragestellung.

58:26.560 --> 58:31.960
Vielleicht gehe ich dazu einfach mal zurück.

58:33.620 --> 58:34.080
Genau.

58:39.280 --> 58:44.280
Das passiert einfach dadurch, dass ich in der aktualisierenden Methode

58:44.280 --> 58:48.800
den Zustand mitgebe, wie auch immer, in irgendeinem Objekt mit

58:48.800 --> 58:52.320
irgendeinem Datentyp, was auch immer, oder ein eigenes Objekt, was ich

58:52.320 --> 58:53.120
mir selbst gebaut habe.

58:53.460 --> 58:54.440
Und da ist genau das Problem.

58:55.560 --> 58:57.780
Die Beobachter müssen die dann kennen.

58:58.280 --> 59:02.420
Sie müssen wissen, was denn da auf sie zukommt.

59:03.260 --> 59:06.280
Sie müssen die möglichen Benachrichtigungen, die da kommen, kennen.

59:06.540 --> 59:08.140
Sie können ja auch unterschiedliche erzeugen.

59:08.640 --> 59:11.560
Sie können ja auch sagen, der Zustand hat sich so geändert, deshalb

59:11.560 --> 59:12.660
gibt es jetzt Objekt X.

59:13.380 --> 59:16.420
Oder der Zustand hat sich so geändert, deshalb gibt es jetzt Objekt Y

59:16.420 --> 59:17.420
vom Datentyp Z.

59:18.280 --> 59:21.000
Und dann müssen Sie im Beobachter mit all dem umgehen können.

59:21.700 --> 59:24.260
Und das ist genau da, wo die Kopplung dann wieder stärker wird.

59:29.620 --> 59:31.100
Genau, hier waren wir stehen geblieben.

59:33.340 --> 59:36.160
Gibt es soweit noch Fragen hierzu?

59:40.210 --> 59:41.690
Ich schaue mich um und sehe keine.

59:44.570 --> 59:50.810
Dann kommen wir tatsächlich direkt zum nächsten.

59:52.650 --> 59:56.050
Und ich muss sagen, ich bin selber kein großer Fan davon.

59:56.190 --> 59:59.170
Ich bin der Meinung, die Brücke ist etwas akademisch.

59:59.930 --> 01:00:05.330
Man sieht sie relativ selten und trotzdem hat sie ihre

01:00:05.330 --> 01:00:06.270
Daseinsberechtigung.

01:00:07.170 --> 01:00:14.330
Auch da wieder der Tipp, lesen Sie das Headfirst Design Patterns.

01:00:14.450 --> 01:00:18.390
Das erklärt das deutlich besser, als wir das hier in der Zeit könnten.

01:00:18.970 --> 01:00:20.850
Wozu man das denn tatsächlich braucht.

01:00:22.110 --> 01:00:25.570
Die Brücke hat noch so ein kleines anderes Problem.

01:00:25.570 --> 01:00:40.510
Wir bauen eine Abstraktion und die ist entkoppelt von der eigentlichen

01:00:40.510 --> 01:00:40.810
Implementierung.

01:00:42.650 --> 01:00:45.490
Und das Problem, was dabei entsteht für die Brücke und warum die

01:00:45.490 --> 01:00:49.190
relativ selten angewendet werden kann, sinnvoll ist, dass das erst

01:00:49.190 --> 01:00:51.630
Sinn macht, wenn das relativ groß wird.

01:00:52.990 --> 01:00:56.550
Und dann muss man erst mal sehen, dass man die sinnvoll anwenden kann.

01:00:57.210 --> 01:01:00.950
Das heißt, wenn wir eine Skala haben von, hier sind die

01:01:00.950 --> 01:01:05.110
implementierungsnahen Entwurfsmuster und hier sind eher die, die schon

01:01:05.110 --> 01:01:09.850
nah bei den Architekturstilen sind, dann würde ich sagen, ist die

01:01:09.850 --> 01:01:10.750
Brücke eher hier.

01:01:11.630 --> 01:01:14.550
Also das geht schon sehr in Richtung Architektur.

01:01:16.190 --> 01:01:18.850
Nichtsdestotrotz schauen wir uns mal an, was die Brücke denn so kann

01:01:18.850 --> 01:01:19.370
und leistet.

01:01:20.190 --> 01:01:23.290
Hier stehen wieder Synonyme Handle und Body, auch damit Sie das mal

01:01:23.290 --> 01:01:23.870
gehört haben.

01:01:27.210 --> 01:01:29.870
Was macht denn jetzt diese Brücke?

01:01:31.950 --> 01:01:37.710
Zunächst einmal schauen Sie sich mal dieses Klassendiagramm an und

01:01:37.710 --> 01:01:41.690
sehen Sie, wir haben hier eine wunderschöne Brücke, Pfeiler 1, Pfeiler

01:01:41.690 --> 01:01:42.090
2.

01:01:42.810 --> 01:01:45.590
Hier fließt das Wasser durch.

01:01:45.590 --> 01:01:48.710
So müssen Sie sich die Brücke vorstellen, deshalb heißt sie Brücke.

01:01:49.490 --> 01:01:59.330
Und was wir haben, sind im Grunde parallele Vererbungshierarchien auf

01:01:59.330 --> 01:02:00.410
beiden Seiten der Pfeiler.

01:02:00.690 --> 01:02:03.130
Und das ist genau der Moment, wann man das braucht.

01:02:03.570 --> 01:02:09.730
Sie haben hier viele Abstraktionen, Ebenen, die aufgebaut werden.

01:02:09.730 --> 01:02:16.030
Sie haben hier unterschiedliche Implementierungen, eine Implementierer

01:02:16.030 --> 01:02:16.670
-Schnittstelle.

01:02:17.610 --> 01:02:21.770
Und Sie wollen sich weder hier noch hier darum kümmern, dass Sie alle

01:02:21.770 --> 01:02:26.110
Abstraktionen in der konkreten Implementierung darstellen können, noch

01:02:26.110 --> 01:02:26.710
andersherum.

01:02:27.530 --> 01:02:31.690
Und deshalb gibt es dieses Entwurfsmuster Brücke, damit die Kopplung

01:02:31.690 --> 01:02:34.870
zwischen der ursprünglichen Abstraktion, der höchsten

01:02:34.870 --> 01:02:38.670
Abstraktionsebene und dem Implementierer auf der anderen Seite, nur

01:02:38.670 --> 01:02:39.350
hergestellt wird.

01:02:42.770 --> 01:02:47.310
Das ist jetzt vielleicht ein bisschen sehr abstrakt gewesen für Sie,

01:02:47.470 --> 01:02:47.870
sehe ich ein.

01:02:48.430 --> 01:02:55.010
Deshalb hier jetzt ein Beispiel, wie man das dann bauen oder wie man

01:02:55.010 --> 01:02:57.450
etwas bauen könnte, wenn man das nicht benutzt.

01:02:59.130 --> 01:03:06.070
Sie haben in einer beliebigen Grafikimplementierung vielleicht Fenster

01:03:06.070 --> 01:03:09.790
und Sie haben hier ein X-Fenster und PM-Fenster als Abstraktion auf

01:03:09.790 --> 01:03:10.310
der einen Seite.

01:03:11.090 --> 01:03:16.550
Und auf der Implementierungsseite oder Sie implementieren dann weiter

01:03:16.550 --> 01:03:21.350
Ihre Fenster, haben dann ein X-Fenster, ein PM-Fenster und ein Icon

01:03:21.350 --> 01:03:23.750
-Fenster und die wollen Sie dann auch noch irgendwie kombinieren.

01:03:24.170 --> 01:03:27.490
Und dann haben Sie plötzlich davon wieder geerbt, ein X-Icon-Fenster

01:03:27.490 --> 01:03:29.250
oder ein PM-Icon-Fenster.

01:03:30.230 --> 01:03:32.330
Und so zieht sich das dann weiter durch.

01:03:32.430 --> 01:03:34.030
Sie merken schon, was dann passiert.

01:03:34.030 --> 01:03:37.150
Das wird irgendwann exponentiell in der Vererbungshierarchie.

01:03:37.510 --> 01:03:41.230
Wir erben dann plötzlich wild durch die Gegend und kombinieren alles

01:03:41.230 --> 01:03:41.610
mit allem.

01:03:42.970 --> 01:03:47.590
Und das ist genau der Moment, wo die Brücke interessant wird.

01:03:51.170 --> 01:03:54.990
Sie sehen wieder hier ein Pfeiler, noch ein Pfeiler.

01:03:55.410 --> 01:03:56.550
Hier fließt das Wasser durch.

01:03:58.190 --> 01:04:02.730
Und Sie sehen jetzt hier die Fensterabstraktion, die

01:04:02.730 --> 01:04:03.550
Fensterimplementierung.

01:04:05.450 --> 01:04:10.350
Und Sie sehen hier die beiden nachgelagerten Abstraktionsebenen, das

01:04:10.350 --> 01:04:15.690
heißt die erbenden Klassen von Icon-Fenster und Transientes Fenster

01:04:15.690 --> 01:04:19.830
und auf der anderen Seite die Implementierung.

01:04:22.930 --> 01:04:30.230
Und dadurch, dass Sie jetzt diese Brücke gebaut haben, können Sie das

01:04:30.230 --> 01:04:35.550
X -Fenster genauso benutzen wie ein normales Fenster und es wird

01:04:35.550 --> 01:04:38.930
trotzdem so gebaut, wie Sie es denn haben möchten.

01:04:39.030 --> 01:04:41.850
Das heißt, Sie müssen hier diese ganzen Kombinationen nicht mehr

01:04:41.850 --> 01:04:42.110
bauen.

01:04:44.350 --> 01:04:46.130
Oh ja, meine Lieblingsfolie.

01:04:47.850 --> 01:04:52.090
Das, was ich schon die ganze Zeit mit wilden Laserpointer-Gefuchtel

01:04:52.590 --> 01:04:55.470
versucht habe, Ihnen zu zeigen, sehen Sie jetzt nochmal hier als

01:04:55.470 --> 01:04:56.130
nettes Overlay.

01:04:56.470 --> 01:04:58.650
Da hat sich jemand verkünstelt und tatsächlich über die Brücke eine

01:04:58.650 --> 01:04:59.250
Brücke gelegt.

01:05:00.930 --> 01:05:03.810
Damit Sie das auch nochmal sehen, die beiden Pfeiler und wo denn

01:05:03.810 --> 01:05:05.250
tatsächlich das Wasser zwischendurch fließt.

01:05:06.310 --> 01:05:08.970
Das vielleicht nochmal so am Rande.

01:05:10.690 --> 01:05:15.370
Hier haben wir noch ein anderes Anwendungsbeispiel, nämlich Java

01:05:15.370 --> 01:05:16.050
-Installationen.

01:05:16.090 --> 01:05:20.730
Sie können unterschiedliche Java-Installationen auf Ihrer Maschine

01:05:20.730 --> 01:05:21.010
haben.

01:05:21.110 --> 01:05:23.690
Das ist jetzt unsere abstrakte Seite.

01:05:25.810 --> 01:05:31.150
Wenn Sie dann eine Anwendung haben, die Java benutzt, dann darf die

01:05:31.150 --> 01:05:33.750
selber entscheiden, welche Variante sie benutzt.

01:05:34.150 --> 01:05:39.190
Sie weiß, die Funktion, die es gibt, kann sie benutzen und die gibt es

01:05:39.190 --> 01:05:41.230
in allen Java-Implementierungen.

01:05:42.670 --> 01:05:44.650
Und das ist genau der Vorteil.

01:05:44.830 --> 01:05:48.750
Sie müssen sich dann nicht mehr darauf verlassen, als implementiertes

01:05:48.750 --> 01:05:49.070
Programm.

01:05:49.190 --> 01:05:50.730
Ich habe hier Java-Version XY.

01:05:50.950 --> 01:05:53.790
Ich weiß, das gilt auch nicht immer, aber im Allgemeinen können Sie

01:05:53.790 --> 01:05:56.670
dann sagen, diese Grundfunktion, die gibt es auf alle Fälle, die kann

01:05:56.670 --> 01:05:57.150
ich benutzen.

01:06:02.230 --> 01:06:04.110
Hier sehen Sie die Anwendbarkeit.

01:06:04.610 --> 01:06:07.570
Wenn wir diese dauerhafte Verbindung zwischen der Implementierung auf

01:06:07.570 --> 01:06:10.810
der einen Seite und der Abstraktion auf der anderen Seite vermeiden

01:06:10.810 --> 01:06:14.370
wollen und insbesondere, wenn wir das nicht alles so kombinieren

01:06:14.370 --> 01:06:16.630
wollen, dass wir da einen riesigen Entwurf daraus bekommen.

01:06:18.450 --> 01:06:25.490
Das ist, glaube ich, das, was der zweite Punkt sagen möchte.

01:06:28.430 --> 01:06:33.630
Und was wir auch noch wollen, ist, wenn wir Änderungen in unserer

01:06:33.630 --> 01:06:38.650
Implementierung in der Abstraktion haben, dann wollen wir da keine

01:06:38.650 --> 01:06:39.870
Auswirkungen haben.

01:06:40.110 --> 01:06:43.250
Das ist das, was wir gerade in dem Java-Beispiel hatten.

01:06:43.310 --> 01:06:44.670
Wir wollen das einfach weiter benutzen können.

01:06:47.450 --> 01:06:48.350
Was haben wir noch?

01:06:50.330 --> 01:06:56.690
Wir wollen die Implementierung der Abstraktion vollständig verstecken

01:06:56.690 --> 01:06:58.030
vor dem eigentlichen Klienten.

01:06:58.110 --> 01:06:59.610
Auch da passt wieder das Java-Beispiel.

01:07:00.290 --> 01:07:02.610
Sie wissen nicht, wie das implementiert ist und wollen das auch gar

01:07:02.610 --> 01:07:02.950
nicht wissen.

01:07:04.110 --> 01:07:08.470
Und jetzt wieder der Punkt mit dem Beispiel, wir wollen nicht, dass

01:07:08.470 --> 01:07:09.890
unsere Klassenhierarchie explodiert.

01:07:11.110 --> 01:07:14.790
Und auch da wieder der Hinweis, es gibt in Headfirst ein sehr schönes

01:07:14.790 --> 01:07:17.870
Beispiel, wie das dann tatsächlich explodiert ohne die Brücke.

01:07:21.050 --> 01:07:23.710
Und dann das Letzte, was noch wichtig ist.

01:07:24.190 --> 01:07:26.810
Wir brauchen das dann, wenn die Implementierung von mehreren Objekten

01:07:28.250 --> 01:07:31.790
gemeinsam benutzt werden soll.

01:07:33.430 --> 01:07:37.310
Aber das ist jetzt auch wieder ein sehr abstrakter Grund, warum das so

01:07:37.310 --> 01:07:37.810
sein sollte.

01:07:38.370 --> 01:07:42.370
Wie gesagt, die Brücke tatsächlich anzuwenden, ist häufig schwierig.

01:07:43.170 --> 01:07:45.270
Behalten Sie es trotzdem im Hintergrund, weil sehen werden Sie es ab

01:07:45.270 --> 01:07:45.530
und zu.

01:07:46.290 --> 01:07:48.370
Und vielleicht finden Sie ja tatsächlich mal einen Fall, wo Sie das

01:07:48.370 --> 01:07:50.430
selber gewinnbringend einsetzen können.

01:07:52.170 --> 01:07:54.870
Gut, ein bisschen Zeit haben wir noch.

01:07:54.870 --> 01:08:00.890
Also machen wir noch weiter mit einer Sache, die vielleicht ein

01:08:00.890 --> 01:08:04.850
bisschen näher oder deutlich näher wieder an der Implementierung dran

01:08:04.850 --> 01:08:05.110
ist.

01:08:05.310 --> 01:08:07.770
Und das ist der Iterator.

01:08:09.150 --> 01:08:10.690
Was macht jetzt ein Iterator?

01:08:10.770 --> 01:08:13.790
Iterator haben Sie bestimmt alle schon mal selber gesehen, auch was

01:08:13.790 --> 01:08:14.170
der tut.

01:08:14.890 --> 01:08:20.630
Nämlich, der ermöglicht einen sequentiellen Zugriff auf Elemente eines

01:08:20.630 --> 01:08:23.090
zusammengesetzten Objektes.

01:08:23.090 --> 01:08:27.890
Also Sie haben ein mengenwertiges Objekt und wollen durch die

01:08:27.890 --> 01:08:32.590
einzelnen Elemente Ihres mengenwertigen Objektes durchiterieren.

01:08:32.810 --> 01:08:35.050
Und eben genau das leistet der Iterator.

01:08:36.550 --> 01:08:42.110
Was Sie aber wollen, ist, dass wenn Sie von außen dadurch iterieren,

01:08:43.290 --> 01:08:45.170
wollen Sie nicht wissen, wie das funktioniert.

01:08:46.410 --> 01:08:47.630
Sie wollen das einfach haben.

01:08:47.990 --> 01:08:49.470
Und genau dafür ist der Iterator da.

01:08:50.050 --> 01:08:54.970
Der bietet Ihnen eben genau diese Transparenz, dass Sie eben nicht

01:08:54.970 --> 01:08:58.430
wissen müssen, wie dieses mengenwertige Objekt aussieht, sondern wenn

01:08:58.430 --> 01:09:02.690
Sie sagen, Iterator, gib mir das nächste Objekt aus der Menge, dann

01:09:02.690 --> 01:09:03.230
tut er das.

01:09:03.450 --> 01:09:04.630
Egal, wo der das herzaubert.

01:09:05.510 --> 01:09:08.630
Und das ist genau der Moment, wo man den Iterator braucht.

01:09:10.330 --> 01:09:12.650
Jetzt habe ich die Synonyme weggeklickt.

01:09:12.750 --> 01:09:16.090
Der Enumerator ist ein Synonym und der robuste Iterator, ja, sehr

01:09:16.090 --> 01:09:16.770
hübsch.

01:09:18.750 --> 01:09:23.830
In Java ist es tatsächlich so, ist der Enumerator der Vorgänger des

01:09:23.830 --> 01:09:24.490
Iterators.

01:09:25.070 --> 01:09:27.530
Wer da mal zu viel Zeit und Langeweile hat, kann sich mal durch die

01:09:27.530 --> 01:09:30.310
Dokumentation klicken und sich das anschauen, warum das so ist.

01:09:31.530 --> 01:09:35.510
Den Enumerator gab es tatsächlich schon bei Java in der ersten Version

01:09:35.510 --> 01:09:38.890
und Iterator glaube ich ab 1.2.

01:09:39.550 --> 01:09:41.150
Bin mir nicht mehr ganz sicher, aber ich glaube.

01:09:41.150 --> 01:09:46.650
Und das hat einfach da den Grund, dass der Iterator nur das nächste

01:09:46.650 --> 01:09:52.130
Objekt liefern konnte und sagen konnte, ja, es gibt noch ein nächstes

01:09:52.130 --> 01:09:57.070
Element, aber was der Enumerator nicht kann, ist Elemente aus der

01:09:57.070 --> 01:09:57.950
Menge löschen.

01:09:58.390 --> 01:09:59.410
Das bietet der Iterator.

01:09:59.950 --> 01:10:06.210
Deshalb hat man da diesen Iterator hinzugefügt in Java und wenn Sie

01:10:06.210 --> 01:10:09.510
die Dokumentation des Enumerators aufmachen, den Sie immer noch nutzen

01:10:09.510 --> 01:10:13.690
können, steht da irgendwo die Notiz tun Sie das nicht, benutzen Sie

01:10:13.690 --> 01:10:15.010
einen Iterator.

01:10:16.010 --> 01:10:18.150
Gut, das am Rande.

01:10:18.550 --> 01:10:22.350
Jetzt dazu, wie sieht denn tatsächlich so ein Iterator aus?

01:10:23.170 --> 01:10:25.270
Wir haben auf der einen Seite

01:10:28.630 --> 01:10:29.910
eine Aggregatschnittstelle.

01:10:30.030 --> 01:10:34.770
Das ist im Grunde die Schnittstelle, die Sie später implementieren

01:10:34.770 --> 01:10:39.130
müssen oder sollen, wenn Sie so ein mengenwertiges Objekt

01:10:43.770 --> 01:10:45.610
darstellen möchten mit Ihrer Implementierung.

01:10:46.790 --> 01:10:48.870
In Java heißt das Iterable.

01:10:49.130 --> 01:10:51.690
Wenn Sie so etwas haben wollen, wenn Sie einen Iterator benutzen

01:10:51.690 --> 01:10:56.330
wollen für Ihre eigene Klassenimplementierung, dann implementieren Sie

01:10:56.330 --> 01:10:56.790
Iterable.

01:10:58.890 --> 01:11:03.170
Das sorgt einfach nur dafür, dass man eine Klasse Iterator hat, die

01:11:03.170 --> 01:11:05.690
einen bestimmten Iterator zurückliefert.

01:11:07.650 --> 01:11:13.690
Auf der anderen Seite haben wir dann das Iterator Interface und wie

01:11:13.690 --> 01:11:18.370
ich gerade eben schon gesagt habe, das leistet im Wesentlichen die

01:11:18.370 --> 01:11:22.310
Funktionalität, dass es das nächste Objekt aus der Menge herausgeben

01:11:22.310 --> 01:11:22.610
kann.

01:11:23.490 --> 01:11:31.310
Es kann auch ein Element entfernen und man kann auch noch angeben,

01:11:31.970 --> 01:11:35.310
gibt es denn überhaupt ein nächstes Element.

01:11:35.550 --> 01:11:37.990
Das macht diese hatNächstes-Methode.

01:11:39.270 --> 01:11:43.950
Und wenn Sie dann einen konkreten Iterator haben, dann implementieren

01:11:43.950 --> 01:11:46.950
Sie den eben so, dass er eben genau das tut.

01:11:47.030 --> 01:11:51.510
Sie könnten da ja einen Array intern benutzen, dann muss der Iterator

01:11:51.510 --> 01:11:54.390
eben wissen, dass man das nächste Array-Element rausnimmt.

01:11:54.390 --> 01:11:56.430
Man könnte eine verkettete Liste haben, dann funktioniert das

01:11:56.430 --> 01:11:57.110
natürlich anders.

01:11:57.770 --> 01:12:02.470
Je nachdem, was in Ihrem konkreten Aggregat dann benutzt wird.

01:12:05.890 --> 01:12:08.070
Schauen wir uns mal ein Beispiel an.

01:12:08.470 --> 01:12:11.410
Da sind wir jetzt wieder bei Java.

01:12:13.370 --> 01:12:18.410
Dort gibt es Listen, abstrakte Listen, Array-Listen in dieser

01:12:18.410 --> 01:12:20.610
Vererbungs -Hierarchie, wie Sie sehen.

01:12:20.610 --> 01:12:26.830
Und eine abstrakte Liste gibt unter anderem diesen Iterator vor.

01:12:26.930 --> 01:12:29.810
Das heißt, das muss dann in Ihrer konkreten Implementierung

01:12:29.810 --> 01:12:33.750
implementiert werden, dass der passende Iterator zurückgegeben wird.

01:12:34.510 --> 01:12:38.530
Es gibt das Interface-Iterator, was genau das liefert, was ich gerade

01:12:38.530 --> 01:12:42.050
eben schon gesagt habe.

01:12:43.670 --> 01:12:47.110
Und der kann auch noch weiter angepasst werden.

01:12:47.110 --> 01:12:50.690
Sie können auch noch spezielle Interfaces haben für einen Listen

01:12:50.690 --> 01:12:54.070
-Iterator oder für einen Array-List-Iterator, so wie das in Java ist.

01:12:54.950 --> 01:12:58.950
Und der kann dann noch zusätzliche Methoden anbieten.

01:12:59.470 --> 01:13:02.430
Oder die Schnittstelle kann dann noch zusätzliche Methoden anbieten,

01:13:02.730 --> 01:13:09.010
die vielleicht für das spezielle Aggregat, für die spezielle Liste

01:13:09.010 --> 01:13:11.090
noch zusätzlich geeignet sind.

01:13:13.890 --> 01:13:18.650
Vielleicht, bevor ich weitermache, Fragen bis hierher zum Iterator

01:13:18.650 --> 01:13:21.130
-Entwurfsmuster.

01:13:22.070 --> 01:13:24.290
Wahrscheinlich relativ klar, hat jeder schon mal gesehen.

01:13:24.930 --> 01:13:27.850
Und wie man das selber bauen könnte, ist wahrscheinlich auch relativ

01:13:27.850 --> 01:13:28.150
klar.

01:13:29.430 --> 01:13:30.570
Hier ein Beispiel.

01:13:30.910 --> 01:13:36.990
Man kann theoretisch durch Verzeichnungsstrukturen iterieren.

01:13:37.570 --> 01:13:42.570
Und auch da möchte man natürlich nicht wissen, wie das intern zu

01:13:42.570 --> 01:13:43.150
funktionieren hat.

01:13:43.190 --> 01:13:44.130
Man möchte es einfach nur können.

01:13:45.970 --> 01:13:49.810
Und der Iterator muss sich dann eben darum kümmern, wie kommt man an

01:13:49.810 --> 01:13:52.010
das nächste Element in der Liste.

01:13:52.850 --> 01:13:55.370
Man selber muss aber nicht wissen, wie das funktioniert.

01:13:57.470 --> 01:14:01.610
Vielleicht nochmal lieber eine Implementierung in Java anschauen.

01:14:03.550 --> 01:14:09.110
Wenn wir uns zum Beispiel mal die erweiterte Schnittstelle des Listen

01:14:09.110 --> 01:14:15.370
-Iterators anschauen, dann sehen wir, wir haben hier noch ein Add

01:14:15.370 --> 01:14:19.370
dazu, wir haben ein Next Index, wir können auch zurückspringen in

01:14:19.370 --> 01:14:19.870
unserer Liste.

01:14:20.750 --> 01:14:25.130
Das sind dann Zusatzfunktionen, die die erweiterte Iterator

01:14:25.130 --> 01:14:26.770
-Schnittstelle liefert.

01:14:29.090 --> 01:14:32.850
Nichtsdestotrotz können wir aber natürlich immer die Schnittstelle

01:14:32.850 --> 01:14:33.550
hier oben benutzen.

01:14:33.550 --> 01:14:37.410
Also mindestens die Funktion haben wir immer zur Verfügung, ohne zu

01:14:37.410 --> 01:14:41.690
wissen, welchen konkreten Iterator wir jetzt gerade in der Hand haben.

01:14:43.230 --> 01:14:48.570
Das hat den großen Vorteil, dass wir das ForEach, was Ihnen vielleicht

01:14:48.570 --> 01:14:51.430
bekannt ist, aus Java benutzen können.

01:14:52.150 --> 01:14:56.090
Das heißt, wir können mit ForEach durch eine komplette, mengenwertige

01:14:56.090 --> 01:15:00.310
Datenstruktur durchiterieren und das funktioniert eben genau über

01:15:00.310 --> 01:15:00.990
diese Iteratoren.

01:15:03.390 --> 01:15:08.610
Das hat einfach den Vorteil, wir können unseren Code ein bisschen

01:15:08.610 --> 01:15:09.730
knapper gestalten.

01:15:10.690 --> 01:15:14.290
Wir haben hier einmal die Variante, wenn wir das nicht tun, da haben

01:15:14.290 --> 01:15:20.510
wir in dem Fall eine Arraylist mit Strings und holen uns dann für

01:15:20.510 --> 01:15:22.570
diese Arraylist den Iterator.

01:15:24.170 --> 01:15:27.350
Und wenn wir diesen Iterator dann haben, dann werfen wir eine

01:15:27.350 --> 01:15:31.970
Wildschleife an, die zunächst einmal prüft, gibt es denn noch ein

01:15:31.970 --> 01:15:37.590
nächstes Element in unserer mengenwertigen Datenstruktur?

01:15:37.850 --> 01:15:42.090
Und wenn ja, dann gib mir das doch bitte auf der Konsole aus.

01:15:44.570 --> 01:15:47.190
Die zweite Variante, die ist natürlich deutlich schöner.

01:15:48.150 --> 01:15:51.370
Da haben wir die Variante mit ForEach und sehen, wir können hier

01:15:51.370 --> 01:15:55.750
einfach über die String Arraylist, die wir uns vorher gebaut haben,

01:15:55.750 --> 01:15:59.630
drüber gehen und können uns die einzelnen Strings rausholen.

01:16:00.850 --> 01:16:06.150
Und das funktioniert eben nur dann, wenn Iterator bzw.

01:16:06.390 --> 01:16:10.510
Iterable in der mengenwertigen Datenstruktur implementiert sind.

01:16:10.650 --> 01:16:15.210
Das heißt, wenn Sie mal selber in die Verlegenheit kommen und möchten

01:16:15.210 --> 01:16:19.530
sich sowas selber bauen, irgendwas, was eine Menge darstellt, dann

01:16:19.530 --> 01:16:23.790
implementieren Sie Iterable und schon kann jemand, der das benutzt,

01:16:24.430 --> 01:16:27.970
dieses wunderbare ForEach benutzen und muss sich nicht extra den

01:16:27.970 --> 01:16:29.310
Iterator holen.

01:16:33.140 --> 01:16:36.040
Ah, wunderbar.

01:16:37.160 --> 01:16:39.020
Ich erzähle Ihnen Dinge, die später noch kommen.

01:16:39.200 --> 01:16:41.880
Da hätte ich mir das ja vorhin sparen können und hätte das hier

01:16:41.880 --> 01:16:42.620
einfach vorlesen können.

01:16:42.780 --> 01:16:45.700
Also hier steht nochmal genau das, was ich vorhin versucht habe, da

01:16:45.700 --> 01:16:51.340
irgendwo aus meinem Kopf zu kramen mit dem Enumerator und dem Iterator

01:16:51.340 --> 01:16:51.840
in Java.

01:16:53.880 --> 01:16:54.440
Genau.

01:16:55.740 --> 01:16:59.960
Der Hauptunterschied ist, mal abgesehen davon, dass die TestNext

01:16:59.960 --> 01:17:03.760
-Methode im Enumerator nicht so schön benannt war und deshalb ein

01:17:03.760 --> 01:17:08.380
bisschen unhandlich, war einfach, dass der Enumerator keine Remove

01:17:08.380 --> 01:17:10.500
-Funktion hatte.

01:17:14.500 --> 01:17:17.560
Das heißt also, Sie konnten aus Ihrer mengenwertigen Datenstruktur

01:17:17.560 --> 01:17:21.100
keine Elemente entfernen und das hat man halt im Iterator hinzugefügt.

01:17:22.800 --> 01:17:27.940
Und jetzt kann man sich natürlich überlegen, wenn ich das dann jetzt

01:17:27.940 --> 01:17:32.420
adaptieren möchte und hatte vorher vielleicht eine Enumeration und

01:17:32.420 --> 01:17:36.760
möchte jetzt aber einen Iterator benutzen, ich kann aber gar nichts

01:17:36.760 --> 01:17:38.520
löschen aus meiner Menge.

01:17:39.120 --> 01:17:39.920
Was mache ich denn dann?

01:17:40.860 --> 01:17:43.100
Und dann ist die Antwort, ja, dann werfen Sie halt eine Exception,

01:17:43.220 --> 01:17:45.120
wenn jemand Remove benutzen möchte.

01:17:46.280 --> 01:17:50.580
Und das ist in dem Fall die Unsupported Operation Exception.

01:17:52.620 --> 01:17:56.080
Und jetzt wird es mit der Werbung langsam hier ein bisschen überhand,

01:17:56.100 --> 01:17:58.760
aber auch da gibt es wieder ein schönes Beispiel im Head First Design

01:17:58.760 --> 01:18:02.460
Patterns, was im Grunde genau das aufgreift, was mache ich denn, wenn

01:18:02.460 --> 01:18:05.820
ich etwas nicht löschen kann und im Grunde genau zu dieser Lösung

01:18:05.820 --> 01:18:06.020
kommt.

01:18:06.100 --> 01:18:08.440
Sie müssen eben eine Exception werfen an der Stelle, bleibt Ihnen

01:18:08.440 --> 01:18:10.720
nichts anderes möglich übrig.

01:18:12.140 --> 01:18:14.860
Genau, wann möchte ich den Iterator anwenden?

01:18:16.740 --> 01:18:19.260
Ja, das haben wir glaube ich jetzt auch schon häufig genug gehört.

01:18:19.480 --> 01:18:23.460
Wir möchten über ein mengenwertiges Objekt drüber iterieren, möchten

01:18:23.460 --> 01:18:25.400
aber nichts über die interne Struktur wissen.

01:18:25.500 --> 01:18:28.480
Wir wollen einfach nur die Elemente da raushaben.

01:18:28.720 --> 01:18:30.320
Uns interessiert nicht, wie die da abgelegt sind.

01:18:30.420 --> 01:18:31.020
Ist das eine Liste?

01:18:31.140 --> 01:18:31.720
Ist das ein Array?

01:18:32.080 --> 01:18:32.880
Ist das sonst was?

01:18:33.120 --> 01:18:34.240
Sind die Einsen aufgezählt?

01:18:35.660 --> 01:18:36.740
Interessiert uns alles nicht.

01:18:36.920 --> 01:18:38.920
Wir wollen nur das nächste Element haben.

01:18:40.600 --> 01:18:44.960
Außerdem haben wir somit eine schöne einheitliche Schnittstelle, um

01:18:44.960 --> 01:18:51.720
über Mengenwertige Objekte drüber zu traversieren.

01:18:54.660 --> 01:19:00.740
Was außerdem noch ganz geschickt ist, ist ein sogenannter Robuster

01:19:00.740 --> 01:19:01.160
-Iterator.

01:19:01.320 --> 01:19:03.440
Und das sind Iteratoren normalerweise.

01:19:03.440 --> 01:19:09.480
Und das bedeutet einfach, dass wenn Sie zwei Iteratoren instanziieren,

01:19:09.880 --> 01:19:12.680
dann laufen die unabhängig voneinander über die Menge.

01:19:13.280 --> 01:19:15.500
Das heißt, der eine weiß vom anderen nichts.

01:19:15.600 --> 01:19:18.440
Die halten selber ihren Zustand, was das nächste Element ist.

01:19:19.160 --> 01:19:22.920
Und das kann in gewissen Situationen auch sehr hilfreich sein.

01:19:25.720 --> 01:19:27.940
Dann sind wir mit dem Iterator durch.

01:19:29.400 --> 01:19:32.160
Da muss man gerade überlegen, ob das noch Sinn macht, den Proxy jetzt

01:19:32.160 --> 01:19:34.180
anzufangen oder ob ich das Prof. Tichy überlasse.

01:19:34.600 --> 01:19:36.320
Ich schaue mal ganz kurz, wie viele vor Ihnen das sind.

01:19:37.720 --> 01:19:39.080
Das reicht wahrscheinlich noch.

01:19:40.640 --> 01:19:43.420
Ja, ich merke schon, das Interesse lässt nach.

01:19:44.860 --> 01:19:46.660
Vielleicht überlasse ich es doch lieber Prof. Tichy.

01:19:46.900 --> 01:19:50.320
Dann bedanke ich mich für Ihre Aufmerksamkeit und nächste Woche macht

01:19:50.320 --> 01:19:51.260
Prof. Tichy wieder weiter.