1
00:00:00,080 --> 00:00:03,760
Dieses Interface wurde für den 
Cheeseburger implementiert, das 

2
00:00:03,760 --> 00:00:07,000
heißt Brötchen, keine Ahnung, 
Patty, was kommt, da kommt da 

3
00:00:07,000 --> 00:00:10,040
überhaupt noch ne Gurke drauf, 
keine Ahnung was war da glaub 

4
00:00:10,040 --> 00:00:11,560
ich noch nie drauf. 
Ne. 

5
00:00:11,840 --> 00:00:15,120
Coding Buddies Dein Podcast rund
um Softwareentwicklung und 

6
00:00:15,200 --> 00:00:17,680
aktueller Tech News herzlich 
Willkommen. 

7
00:00:29,840 --> 00:00:33,440
Einen wunderschönen guten Tag 
und herzlich Willkommen zur 

8
00:00:33,440 --> 00:00:38,600
neuen Folge vom Coding Buddies 
Podcast und Tino begrüße ich 

9
00:00:38,600 --> 00:00:41,120
hier ganz herzlich und ich 
hoffe, Tino, Du hast auch einen 

10
00:00:41,120 --> 00:00:43,640
so wunderschönen Tag, wie ich 
ihn gerade allen hier gewünscht.

11
00:00:43,640 --> 00:00:49,160
Habe ja Moin Moin fabi, ja ich 
habe einen super Tag, es ist 

12
00:00:49,160 --> 00:00:53,040
tolles Wetter, ich genieße das 
so richtig drin zu sein und. 

13
00:00:54,600 --> 00:00:56,240
Um mit dir jetzt n Podcast 
aufzunehmen. 

14
00:00:56,240 --> 00:00:58,840
Ich hab Bock, ich hab Bock. 
Das ist sehr gut, das freut 

15
00:00:58,840 --> 00:01:00,080
mich. 
Wir haben nämlich auch heute 

16
00:01:00,080 --> 00:01:02,560
wieder n sehr interessantes 
Thema. 

17
00:01:02,560 --> 00:01:04,680
Also ich freu mich auf die 
Folge, ich hab da echt Bock 

18
00:01:04,680 --> 00:01:07,440
drauf, hab ich ja sonst auch 
immer, aber irgendwie weißt du 

19
00:01:07,440 --> 00:01:11,200
es gibt immer mal so da da da 
stehst du morgens auf und denkst

20
00:01:11,200 --> 00:01:16,480
dir heute n Podcast aufnehmen. 
Fühl ich so mit dem Thema. 

21
00:01:17,200 --> 00:01:18,640
Ja, ich find es auch. 
Was haben wir denn so? 

22
00:01:18,640 --> 00:01:22,640
Wir haben ja n ganz cooles Thema
heute und zwar wollen wir so 

23
00:01:22,640 --> 00:01:26,240
richtig durchstarten mit unserer
neuen Reihe zum Thema Design 

24
00:01:26,240 --> 00:01:31,120
Pattern und quasi heute mal so 
das erste Pattern besprechen. 

25
00:01:31,360 --> 00:01:34,400
Doch bevor wir sagen, welches 
das ist und so richtig 

26
00:01:34,400 --> 00:01:37,760
reinstarten noch ganz kurz die 
Anmerkung, Liebe Zuhörer, liebe 

27
00:01:37,760 --> 00:01:40,560
Zuhörer, falls dir dieser 
Podcast gefällt, du den 

28
00:01:40,560 --> 00:01:42,880
Abfeierst, ihn vielleicht schon 
länger hörst, so Mehrwert 

29
00:01:42,880 --> 00:01:45,520
rausziehen kannst, schau doch 
mal in die Shownotes, da gibt es

30
00:01:45,520 --> 00:01:47,640
einen kleinen Spendenlink. 
Falls du Bock hast zu uns zu 

31
00:01:47,640 --> 00:01:49,840
unterstützen, wir würden uns 
mega darüber freuen. 

32
00:01:50,160 --> 00:01:53,520
Das nur kurz als Anmerkung. 
Werbung ändern an dem Punkt. 

33
00:01:53,840 --> 00:01:58,080
Und deswegen fabi, Hau doch mal 
raus, was für ein Pattern kommt 

34
00:01:58,080 --> 00:02:02,080
heute, wir haben es ja in der 
Einleitungsfolge schon mal etwas

35
00:02:02,080 --> 00:02:05,000
angeteasert und genau das haben 
wir auch jetzt gemacht. 

36
00:02:05,000 --> 00:02:07,840
Wir haben gesagt, wir nehmen 
einfach ein Pattern, was ich 

37
00:02:07,840 --> 00:02:10,800
glaube einfach wirklich, 
wirklich, wirklich oft einem 

38
00:02:10,800 --> 00:02:14,400
über den Weg läuft und zwar das 
Factory Pattern und ich finde 

39
00:02:14,400 --> 00:02:18,800
auch persönlich ist es auch ein.
Pattern, was ich auch häufig 

40
00:02:19,040 --> 00:02:23,480
sehe, häufig nutze also auch 
selber und ich finde irgendwie, 

41
00:02:23,480 --> 00:02:25,560
das ist so ein Klassiker und 
deswegen können wir einfach mal 

42
00:02:25,560 --> 00:02:29,160
mit diesem Klassiker einfach 
anfangen und durchstarten und 

43
00:02:29,160 --> 00:02:33,200
einfach mal gucken okay ne, was 
ist das, wann nutzt man das, 

44
00:02:33,760 --> 00:02:36,760
wofür benutzt man das? 
Und diese Fragen klären wir 

45
00:02:36,760 --> 00:02:40,080
einfach mal alle und zeigen 
natürlich, was es also wie das 

46
00:02:40,080 --> 00:02:43,240
aufgebaut ist, ne. 
Genau, also wir hatten ja 

47
00:02:43,240 --> 00:02:45,280
gesagt, dass wir uns heute das 
Factory Pattern anschauen 

48
00:02:45,280 --> 00:02:49,680
wollen. 
Und in der Einleitungsfolge sag 

49
00:02:49,680 --> 00:02:52,240
ich mal, haben wir ja auch 
gesagt, warum Pattern so wichtig

50
00:02:52,240 --> 00:02:54,640
sind. 
Noch mal kurz genannt, um 

51
00:02:54,640 --> 00:02:57,320
einfach Strukturen den Code zu 
kriegen, besser testbaren Code 

52
00:02:57,320 --> 00:03:01,520
zu haben, Skalierbarer und 
Wartbarer zu sein und das kann 

53
00:03:01,520 --> 00:03:04,760
man am Factory Pattern auch ganz
gut schon sehen und deswegen ist

54
00:03:04,760 --> 00:03:08,480
es auch n super einstiegspattern
sag ich mal, weil man kann es 

55
00:03:08,480 --> 00:03:10,600
auch mit. 
Mit Analogien gut erklären und 

56
00:03:10,600 --> 00:03:12,400
ich weiß, du bist Fan von 
Analogien. 

57
00:03:12,400 --> 00:03:17,120
Fabi, da kannst du dich richtig 
austoben heute aber mal ganz 

58
00:03:17,120 --> 00:03:19,920
kurz allgemein, warum überhaupt 
Factory pattern? 

59
00:03:20,160 --> 00:03:22,560
Also wir bewegen uns heute so n 
bisschen in der 

60
00:03:22,560 --> 00:03:25,680
objektorientierten Welt, das 
noch als Anmerkung dazu. 

61
00:03:26,080 --> 00:03:29,480
Ja. 
Und jeder, der vielleicht gerade

62
00:03:29,480 --> 00:03:32,000
am Anfang ist, sich mit der 
Objektorientierung zu 

63
00:03:32,000 --> 00:03:37,200
beschäftigen, beispielsweise mit
Javas startet und da ja 

64
00:03:37,200 --> 00:03:40,160
notgedrungen in die 
Objektorientierung kommt, was ja

65
00:03:40,160 --> 00:03:42,440
nichts Schlechtes ist. 
Nicht falsch verstehen, aber der

66
00:03:42,440 --> 00:03:45,320
wird das Halt merken, dass 
gerade am Anfang, dann hast du 

67
00:03:45,320 --> 00:03:48,880
überall New im Code, überall 
werden Objekte erzeugt, du weißt

68
00:03:48,880 --> 00:03:51,640
gar nicht mehr, auf welchen du 
jetzt arbeiten sollst. 

69
00:03:51,640 --> 00:03:54,160
Du hast ne hohe Kopplung des 
Codes, du kannst das nicht mehr 

70
00:03:54,160 --> 00:03:56,640
so wirklich extrahierend 
voneinander und. 

71
00:03:56,960 --> 00:03:59,760
Wie sagt man so schön Dead 
escalated Quickly? 

72
00:04:00,400 --> 00:04:02,880
Also du kommst halt dann auch 
schnell an den Punkt, wo es 

73
00:04:02,880 --> 00:04:07,280
einfach unübersichtlich wird und
da möchte ich wirklich mal mit 

74
00:04:07,280 --> 00:04:09,600
einer Analogie starten. 
Fabi, Ich hoffe du greifst die 

75
00:04:09,600 --> 00:04:12,640
auf oder hast vielleicht noch ne
andere damit man sich das Ganze 

76
00:04:12,640 --> 00:04:15,840
einfach mal vorstellen kann wie 
man jetzt mit Hilfe eines 

77
00:04:15,840 --> 00:04:19,040
Factory Patterns. 
Mehr Struktur in seinen Code 

78
00:04:19,040 --> 00:04:21,440
bekommt. 
Und zwar möchte ich da, dass ihr

79
00:04:21,440 --> 00:04:24,240
euch alle, liebe Zuhörer, liebe 
Zuhörer, du und vor allem auch 

80
00:04:24,240 --> 00:04:26,800
du Fabi euch folgendes 
vorstellt. 

81
00:04:27,840 --> 00:04:32,400
Ihr seid beispielsweise wieder 
in der Schule oder an der Uni, 

82
00:04:32,880 --> 00:04:38,160
ihr hattet eine anstrengende 
Vorlesung deswegen oder oder 

83
00:04:38,160 --> 00:04:40,960
gerade Unterricht und ihr seid 
so richtig ausgelaugt und was 

84
00:04:40,960 --> 00:04:43,560
wäre jetzt besser als ein kühles
Getränk, weil es ist warm 

85
00:04:43,560 --> 00:04:46,480
draußen ja, also du hast jetzt 
so richtig Bock auf ein kaltes 

86
00:04:46,480 --> 00:04:48,760
Getränk und. 
Und dann steht er da, am Ende 

87
00:04:48,760 --> 00:04:53,360
des Ganges, leuchtend der 
Getränkeautomat, und du rennst 

88
00:04:53,360 --> 00:04:56,440
dahin mit deinen letzten Münzen 
in der Tasche und möchtest dir 

89
00:04:56,440 --> 00:04:59,400
jetzt noch ein schönes kaltes 
Getränk holen und stehst davor 

90
00:04:59,400 --> 00:05:02,240
und siehst die verschiedenen 
Knöpfe, weißt erst mal gar 

91
00:05:02,240 --> 00:05:04,800
nicht, was du nehmen sollst. 
Nimmst du eine Cola, eine Cola 

92
00:05:04,800 --> 00:05:09,840
light, ein Wasser, eine 
Apfelschorle vielleicht und eine

93
00:05:09,840 --> 00:05:13,360
Spezi gibt es auch für dich kein
Problem, hat der Automat am 

94
00:05:13,360 --> 00:05:17,920
Start und. 
Und ja, was passiert jetzt? 

95
00:05:17,920 --> 00:05:21,600
Du schmeißt dein Geld rein und 
drückst einfach auf n Knopf und 

96
00:05:21,600 --> 00:05:25,360
sagst zum Beispiel Wasser und du
bekommst ne Wasserflasche 

97
00:05:25,360 --> 00:05:28,560
daraus, vorzugsweise 
wahrscheinlich n halber Liter 

98
00:05:28,560 --> 00:05:32,560
PET Flasche, aber du bekommst n 
Wasser. 

99
00:05:32,840 --> 00:05:35,400
Hättest du jetzt Cola gedrückt, 
würde der Automat dir Cola 

100
00:05:35,400 --> 00:05:38,920
geben. 
Das heißt abhängig davon, was du

101
00:05:38,920 --> 00:05:42,560
dem Automat als Eingabe gibst, 
kriegst du dementsprechend den 

102
00:05:42,560 --> 00:05:44,560
Output. 
Ja, und das kann man sich jetzt 

103
00:05:44,560 --> 00:05:48,160
wieso n neues Objekt getränkt 
vorstellen, nur das ist in dem 

104
00:05:48,160 --> 00:05:50,760
Fall wenn ich Wasser drücke und 
Wasser ist wenn ich Cola drücke 

105
00:05:50,760 --> 00:05:54,120
ist es ne Cola. 
Das heißt, in diesem Fall ist 

106
00:05:54,120 --> 00:05:58,000
der Automat genau diese Factory 
und das Pattern, was wir heute 

107
00:05:58,000 --> 00:06:01,600
besprechen wollen. 
Denn die Logik was du bekommst 

108
00:06:01,600 --> 00:06:06,000
an Getränk, also als Getränk, 
ist quasi intern im Automat 

109
00:06:06,000 --> 00:06:10,680
gegeben und abhängig von deiner 
Knopfeingabe sagen wir mal da 

110
00:06:10,680 --> 00:06:14,480
drin ist ne Art Switch. 
Ja FLS wie auch immer. 

111
00:06:15,520 --> 00:06:17,760
Wird entschieden, welches 
Getränk ausgegeben wird. 

112
00:06:17,840 --> 00:06:21,280
Das heißt, für dich spielt es 
gar keine Rolle, wie intern 

113
00:06:21,280 --> 00:06:23,280
ausgewählt wird. 
Es spielt für dich nicht mal 

114
00:06:23,280 --> 00:06:25,800
eine Rolle, wie dieses Getränk 
da überhaupt rein gekommen ist. 

115
00:06:25,800 --> 00:06:27,840
Dass das irgendwer aufgefüllt 
hat oder wie das Getränk 

116
00:06:27,840 --> 00:06:31,600
abgefüllt wurde oder was auch 
immer es spielt für dich in dem 

117
00:06:31,600 --> 00:06:34,880
Fall keine Rolle, sondern es 
spielt nur eine Rolle. 

118
00:06:34,880 --> 00:06:36,960
Ich möchte jetzt auf Wasser 
drücken und dann möchte ich 

119
00:06:36,960 --> 00:06:39,280
bitte auch ein Wasser bekommen, 
der Rest ist mir egal und. 

120
00:06:39,960 --> 00:06:42,320
Und ich finde, daran kann man 
das schon mal ganz gut erklären 

121
00:06:42,320 --> 00:06:45,840
oder beziehungsweise verstehen, 
was dieses Pattern eigentlich 

122
00:06:45,840 --> 00:06:48,400
für n Ziel hat am Ende. 
Ja, also du kriegst ja im 

123
00:06:48,400 --> 00:06:50,720
Endeffekt sozusagen ein, wenn 
man jetzt so n bisschen, weil du

124
00:06:50,720 --> 00:06:52,640
ja auf Switch und IF und so 
eingegangen bist. 

125
00:06:52,800 --> 00:06:55,760
Du kriegst ja am Ende so so ne 
Art, ich sag mal Objekt Getränk.

126
00:06:56,360 --> 00:06:58,960
Und was es dann aber speziell 
für ein Getränk ist, das ist im 

127
00:06:58,960 --> 00:07:02,600
Endeffekt erstmal, sage ich 
jetzt mal egal, weil das dieser 

128
00:07:02,600 --> 00:07:05,080
Getränkeautomat kann nur 
Getränke ausspucken und dann ist

129
00:07:05,080 --> 00:07:06,920
es natürlich wichtig. 
Was ist es denn wirklich 

130
00:07:06,920 --> 00:07:09,120
speziell für ein Getränk? 
Also wenn du jetzt zum Beispiel 

131
00:07:09,120 --> 00:07:11,360
sagst Wasser ist dann zum 
Beispiel auf 1 und dann hast du 

132
00:07:11,360 --> 00:07:15,920
zum Beispiel if Eingabe 1 dann 
Wasser if Eingabe oder Else IF 

133
00:07:15,920 --> 00:07:18,480
oder so und so weiter und sofort
oder mit dem Switch wie du 

134
00:07:18,480 --> 00:07:21,440
meintest um sich das jetzt mal 
ganz explizit vorzustellen und 

135
00:07:21,440 --> 00:07:23,240
dann kriegst du halt einfach 
dein dein Getränk da raus. 

136
00:07:23,240 --> 00:07:27,640
Ja finde ich gut, ich finde das.
Also ich hab hätt noch ne andere

137
00:07:27,640 --> 00:07:31,360
Analogie, vielleicht noch mal so
n bisschen um die Vielfalt 

138
00:07:31,360 --> 00:07:34,000
rauszubringen. 
Wenn wir jetzt schon bei Cola 

139
00:07:34,000 --> 00:07:36,360
und und ungesunden Getränken 
waren, dann möchte ich jetzt 

140
00:07:36,360 --> 00:07:37,840
noch n ungesundes Essen 
ansprechen. 

141
00:07:38,880 --> 00:07:41,160
Oh, jetzt bin ich gespannt. 
Zum Beispiel Pizza, ne. 

142
00:07:41,160 --> 00:07:43,200
Also wenn ihr jetzt zum Beispiel
was. 

143
00:07:43,200 --> 00:07:46,840
Ungesund. 
Ja, natürlich nicht. 

144
00:07:46,840 --> 00:07:50,080
Pizza ist sehr gesund, sollte 
man jeden Tag essen, mindestens 

145
00:07:50,080 --> 00:07:56,200
3, mindestens 3, ja wenn nicht 
mehr, nein, auf jeden Fall, ich 

146
00:07:56,200 --> 00:07:58,400
finde, daran kann man sich das 
auch oder kann ich mir das ganz 

147
00:07:58,400 --> 00:08:00,960
gut vorstellen, wenn man sagt 
okay, du gehst in eine Pizzeria 

148
00:08:01,040 --> 00:08:04,880
und möchtest jetzt eine Pizza 
bestellen und du weißt 

149
00:08:04,880 --> 00:08:08,640
eigentlich okay egal welche 
Pizza du bestellst, du hast 

150
00:08:08,640 --> 00:08:11,920
eigentlich immer den gleichen 
Pizzaboden, also der Teig von 

151
00:08:11,920 --> 00:08:15,800
dem Boden ist immer der gleiche.
Die Soße da drauf, die 

152
00:08:15,800 --> 00:08:18,680
Tomatensoße auch immer die 
gleiche, ne so und dann ist 

153
00:08:18,680 --> 00:08:22,040
natürlich nur die Frage OK, was 
möchtest du jetzt drauf haben? 

154
00:08:22,040 --> 00:08:23,640
Ne du gehst jetzt zum Beispiel 
hin du sagst ich möchte ne 

155
00:08:23,680 --> 00:08:26,280
Salamipizza bestellen, also 
bekommst du halt eben diese 

156
00:08:26,280 --> 00:08:30,160
Grundpizza ne Teig und 
Tomatensoße plus dann Salami und

157
00:08:30,160 --> 00:08:34,280
Käse drauf ne oder du sagst ich 
möchte ne Hawaii Pizza haben und

158
00:08:34,280 --> 00:08:37,039
bekommst dann halt eben wieder 
diese Grundpizza mit halt 

159
00:08:37,039 --> 00:08:38,640
Schinken und Ananas ich glaub 
so. 

160
00:08:39,000 --> 00:08:41,600
Ungefähr geht nach Hawaii, bin 
ich jetzt nicht so Fan. 

161
00:08:41,600 --> 00:08:44,240
Von Hawaii hast du doch nur 
gewählt, um jetzt hier Leute zu 

162
00:08:44,240 --> 00:08:47,240
provozieren, die sagen Hawaii 
ist keine Pizza. 

163
00:08:48,560 --> 00:08:52,720
Ja, mal gucken, finde ich gut, 
finde ich gut, gleich war so 

164
00:08:52,720 --> 00:08:55,600
eine Grundsatzdiskussion jetzt 
hier ausbrechen lassen. 

165
00:08:56,080 --> 00:08:59,280
Ja ich bin auch kein Fan von 
Hawaii muss ich sagen, aber ist 

166
00:08:59,280 --> 00:09:00,720
ja Geschmackssache, 
Geschmackssache. 

167
00:09:03,000 --> 00:09:05,000
Genau, aber im Endeffekt gehst 
du ja eigentlich dann am Ende 

168
00:09:05,000 --> 00:09:07,920
aber auch nur hin und ne, also 
wenn du das ganze noch weiter 

169
00:09:07,920 --> 00:09:10,320
abstrahierst, hast du ja in 
vielen Restaurants auch einfach 

170
00:09:10,320 --> 00:09:13,640
nur zahlen, die dann zu mich 
dran stehen und sagst ja ich 

171
00:09:13,640 --> 00:09:16,640
möchte jetzt die 10 ne und 10 
ist dann am Ende beispielsweise 

172
00:09:16,640 --> 00:09:19,680
die Salami ne und dann sagst du 
ich möchte aber zu mich die 14 

173
00:09:19,680 --> 00:09:22,760
und das ist dann aber die die 
Hawaii und wichtig ist ja nur, 

174
00:09:22,760 --> 00:09:27,120
dass du weißt, du möchtest eine 
Pizza Punkt 1 und Punkt 2 ist 

175
00:09:27,360 --> 00:09:31,200
welche denn genau ne? 
Dann sagst du halt entweder den 

176
00:09:31,200 --> 00:09:33,360
Namen oder die Zahl und bekommst
dann halt eben am Ende diese 

177
00:09:33,360 --> 00:09:35,840
Pizza. 
Und wie das jetzt aber 

178
00:09:35,840 --> 00:09:38,400
hergestellt wird, wie du 
meintest ne keine Ahnung, du 

179
00:09:38,400 --> 00:09:41,680
brauchst nicht wissen wie der 
Belag aussieht beziehungsweise 

180
00:09:41,680 --> 00:09:45,520
wie der wie der da drauf gelegt 
wird, wie die Pizzateig Rezeptur

181
00:09:45,520 --> 00:09:48,320
ist, was in die Tomatensoße 
kommt alles egal. 

182
00:09:48,960 --> 00:09:52,320
Das macht alles die Küche ne und
wenn man das jetzt auf Code 

183
00:09:52,320 --> 00:09:55,680
Ebene sieht, dann ist die Küche 
der Defactory und. 

184
00:09:56,040 --> 00:09:59,480
Innerhalb der Factory weiß der 
Code, was da passieren soll, 

185
00:09:59,480 --> 00:10:02,600
aber du von außen, wenn du die 
benutzt diese Factory die 

186
00:10:02,600 --> 00:10:04,960
brauchst, da brauchst du es 
nicht wissen, du willst halt nur

187
00:10:04,960 --> 00:10:06,160
die entsprechenden Pits und so 
ne. 

188
00:10:06,640 --> 00:10:10,320
Und. 
Das ist im Endeffekt dann ja 

189
00:10:10,400 --> 00:10:14,240
auch eine andere Analogie für so
n Factory patter ne. 

190
00:10:14,640 --> 00:10:17,920
Ja, was man daran auch wirklich.
Also es ist auch n sehr gute 

191
00:10:17,920 --> 00:10:19,680
Analogie, vielen Dank dafür, 
fabi. 

192
00:10:20,320 --> 00:10:24,080
Weil wir ein wichtiger Punkt der
ne Factory auch noch mit sich 

193
00:10:24,080 --> 00:10:26,200
bringt. 
Also das Pattern kann man daran 

194
00:10:26,200 --> 00:10:29,560
nämlich auch ganz gut erklären. 
Angenommen jemand bestellt jetzt

195
00:10:29,560 --> 00:10:34,200
ne Salamipizza, fängst du ja 
nicht an zu sagen ich setze 

196
00:10:34,200 --> 00:10:38,160
jetzt n Teig an, ich rühre jetzt
die Soße an oder stell diese 

197
00:10:38,160 --> 00:10:41,760
Soße quasi her, hab dann den 
Teig, die Soße und dann den 

198
00:10:41,760 --> 00:10:45,840
spezifischen Belag für die Pizza
drauf, ne um ne Salamipizza zum 

199
00:10:45,840 --> 00:10:49,240
Beispiel herzustellen, sagen wir
mal das machst du ja nicht in 

200
00:10:49,240 --> 00:10:52,200
dem Fall, sondern du hast ja wie
du meintest diese Grundsoße, die

201
00:10:52,200 --> 00:10:54,720
ist fertig für alle Pizzen, das 
heißt du kannst sie wieder 

202
00:10:54,720 --> 00:10:58,080
verwenden und musst nicht jedes 
Mal neu definieren, wie diese 

203
00:10:58,080 --> 00:11:00,800
Soße aussieht, welche Kräuter da
reinkommen, wie auch immer, 

204
00:11:01,120 --> 00:11:03,920
genauso der Teig, der ist 
fertig, das heißt du musst nicht

205
00:11:03,920 --> 00:11:06,640
jedes Mal wieder neuen Teig 
herstellen, nur um jetzt ne 

206
00:11:06,640 --> 00:11:09,200
Salami oder was hast du gesagt 
ne Hawai Pizza zu machen. 

207
00:11:09,200 --> 00:11:12,320
Ja und daran kann man nämlich 
auch gut erkennen welche 

208
00:11:12,320 --> 00:11:15,480
Vorteile das mit sich bringt, 
weil du kannst ja sagen ich habe

209
00:11:15,480 --> 00:11:17,440
diese Grundpizza und die hat 
Eigenschaften. 

210
00:11:17,640 --> 00:11:20,640
Ja, zum Beispiel der Teig sieht 
so und so aus, die Soße da drauf

211
00:11:20,640 --> 00:11:24,640
ist in der und der Menge da 
drauf und so weiter und darauf 

212
00:11:24,640 --> 00:11:27,400
aufbauend spezifizierst du dann 
ja nur noch wie du meintest die 

213
00:11:27,400 --> 00:11:32,560
Pizza und kannst so quasi 
Objekte schnell und einfach 

214
00:11:32,560 --> 00:11:34,120
herstellen, in dem Fall die 
Pizza. 

215
00:11:34,120 --> 00:11:35,920
Wenn wir jetzt noch mal n 
bisschen in die Coderichtung 

216
00:11:35,920 --> 00:11:38,960
gehen, also quasi in deiner 
objektorientierung Objekte 

217
00:11:38,960 --> 00:11:42,640
herstellen ohne zu wissen wie 
genau sie im Detail gebaut sind,

218
00:11:42,640 --> 00:11:44,760
wie der Teig aussieht, wie die 
Soße aussieht, aber du weißt du 

219
00:11:44,760 --> 00:11:47,440
kriegst ne Pizza. 
Plus die Parameter, die du 

220
00:11:47,440 --> 00:11:50,720
reingibst Salami oder Hawaii 
oder ne Nummer wie du meintest 

221
00:11:50,800 --> 00:11:54,640
und hast dann am Ende n fertiges
Pizzaobjekt, was deinen 

222
00:11:55,280 --> 00:11:57,760
Ansprüchen entspricht, sag ich 
mal. 

223
00:11:57,760 --> 00:12:01,280
Der Code liefert es dir einfach 
ne und das ist eigentlich 

224
00:12:01,440 --> 00:12:04,640
wirklich ne perfekte Analogie um
einfach mal. 

225
00:12:05,240 --> 00:12:08,880
Den Factory Pattern zu zeigen, 
also quasi auch diese Analogie 

226
00:12:08,880 --> 00:12:12,080
mal zu programmieren, einfach 
sich zu sagen, ich habe jetzt 

227
00:12:12,080 --> 00:12:17,520
ein eine basisklasse Pizza und 
habe dann spezifische Pizzen 

228
00:12:17,520 --> 00:12:21,840
sozusagen die ich erzeugen kann,
also alle, die jetzt diese Folge

229
00:12:21,840 --> 00:12:24,400
hören und das mal ausprobieren 
wollen, programmiert ruhig 

230
00:12:24,400 --> 00:12:26,080
danach mal. 
Diese Pizzeria ist eine sehr 

231
00:12:26,080 --> 00:12:29,040
geile Übung. 
Was ich ein bisschen, also was, 

232
00:12:29,040 --> 00:12:33,760
was mich früher am beim Start in
die Softwareentwicklung, was 

233
00:12:33,760 --> 00:12:35,960
mich immer so. 
Ein bisschen verwundert hat an 

234
00:12:35,960 --> 00:12:40,400
diesem, an dieser Beschreibung 
von einer Factory, das das 

235
00:12:40,400 --> 00:12:45,720
heißt, die Factory gibt ja ein 
Objekt und wie dieses Objekt am 

236
00:12:45,720 --> 00:12:49,120
Ende gebaut wird, das ist dir 
egal, das brauchst du nicht 

237
00:12:49,120 --> 00:12:52,640
wissen, das wird von der Factory
bereitgestellt, das Macht der 

238
00:12:52,640 --> 00:12:56,480
Code dahinter und du brauchst 
das Wissen darüber nicht und das

239
00:12:56,480 --> 00:12:59,200
fand ich da dachte ich mal so, 
ich verstehe es nicht ganz am 

240
00:12:59,200 --> 00:13:01,960
Anfang, da dachte ich mir, so 
wie ich bau. 

241
00:13:02,040 --> 00:13:04,720
Bau doch diese Factory, dann 
weiß ich doch wie das 

242
00:13:04,720 --> 00:13:06,560
funktioniert. 
So weißt du da dachte ich mir 

243
00:13:06,560 --> 00:13:07,560
immer so, das macht doch gar 
keinen Sinn. 

244
00:13:07,560 --> 00:13:10,240
Natürlich weiß ich wie das da 
drin aussieht, natürlich muss 

245
00:13:10,240 --> 00:13:13,840
ich wissen wie das passiert und 
das war für mich damals immer so

246
00:13:13,840 --> 00:13:17,760
ein kleiner wie sagt man so, da 
habe ich mir so ein bisschen den

247
00:13:17,760 --> 00:13:21,600
Kopf drüber zerbrochen, im 
Endeffekt ist es ja so, dass 

248
00:13:21,600 --> 00:13:25,200
wenn du normalerweise später 
irgendwann mal in der 

249
00:13:25,200 --> 00:13:26,920
Softwareentwicklung arbeitest, 
dann. 

250
00:13:26,920 --> 00:13:29,680
Dann schreibst du ja nicht den 
kompletten Code für die gesamte 

251
00:13:29,680 --> 00:13:31,360
Anwendung. 
Das heißt, du schreibst 

252
00:13:31,360 --> 00:13:33,880
vielleicht an einer Stelle und 
jemand anders schreibt an einer 

253
00:13:33,880 --> 00:13:37,200
anderen Stelle, das heißt, eine 
Person hat beispielsweise diese 

254
00:13:37,200 --> 00:13:41,480
diese Factory erstellt und du 
kannst sie dann für deine 

255
00:13:41,480 --> 00:13:44,480
Aufgabe nutzen. 
Und in dem Fall ist es dann so, 

256
00:13:44,480 --> 00:13:46,960
dass du natürlich darauf 
vertrauen solltest, dass die 

257
00:13:46,960 --> 00:13:48,720
Factory funktioniert. 
Ist ja auch deine 

258
00:13:48,720 --> 00:13:51,600
Arbeitskollegin oder dein 
Arbeitskollege, der das dann 

259
00:13:51,600 --> 00:13:53,760
implementiert hat, aber du 
kannst dann einfach nur sagen, 

260
00:13:53,760 --> 00:13:56,920
OK, ich möchte jetzt Objekt AB 
oder C haben und das kriege ich 

261
00:13:56,920 --> 00:14:01,120
aus der Factory raus, ne und das
ist halt so n bisschen das war 

262
00:14:02,320 --> 00:14:04,880
ich weiß nicht ob noch 
irgendjemand vielleicht genauso 

263
00:14:04,960 --> 00:14:08,960
mal an diesem Punkt war, aber 
das das hat mich früher. 

264
00:14:09,400 --> 00:14:10,680
Gerade im Studium habe ich das 
immer. 

265
00:14:10,720 --> 00:14:12,360
Ich dachte, was wollen die denn 
von mir. 

266
00:14:12,360 --> 00:14:14,680
Natürlich weiß ich, wie das 
alles aussieht, ich habe es ja 

267
00:14:14,680 --> 00:14:19,680
programmiert. 
Dann, ja, natürlich ist damit ja

268
00:14:19,680 --> 00:14:21,600
nicht gemeint, dass du eine 
Blackbox hast. 

269
00:14:21,600 --> 00:14:24,160
Also gerade wenn du sie selbst 
entwickelst, also das Pattern 

270
00:14:24,160 --> 00:14:26,520
selbst implementierst, geht es 
ja nicht darum, eine Blackbox zu

271
00:14:26,520 --> 00:14:28,320
haben, wo du nicht in den Code 
reingucken kannst. 

272
00:14:28,560 --> 00:14:31,760
Aber um die Wiederverwendbarkeit
und Skalierbarkeit, das ist ja 

273
00:14:31,760 --> 00:14:35,120
das Entscheidende, dass du genau
diese Factory an einer Stelle 

274
00:14:35,120 --> 00:14:38,400
definierst. 
Und dann das Hochskalieren 

275
00:14:38,400 --> 00:14:41,360
kannst, indem du dir halt 
verschiedene Implementierung 

276
00:14:41,360 --> 00:14:45,920
einer Pizza überlegst oder 
implementierst und die dann halt

277
00:14:45,920 --> 00:14:48,920
wieder verwenden kannst. 
Über deine Factory und das 

278
00:14:48,920 --> 00:14:52,720
Entschlankt oder macht ja den 
Code schlank am Ende 

279
00:14:52,720 --> 00:14:54,960
unvorinkalierbar. 
Ja, genau. 

280
00:14:55,040 --> 00:14:58,720
Aber es gibt halt auch, um mal 
ein bisschen fachlicher zu 

281
00:14:58,720 --> 00:15:01,680
werden und so mal richtig in das
Design Pattern reinzukommen. 

282
00:15:02,520 --> 00:15:05,520
Es gibt ja verschiedene Formen 
des Factory Patterns, es gibt 

283
00:15:05,520 --> 00:15:09,440
sozusagen so eine vereinfachte 
Factory, es gibt die klassische,

284
00:15:09,440 --> 00:15:12,600
was auch als Design Pattern so 
quasi in jedem Buch zu finden 

285
00:15:12,600 --> 00:15:14,480
ist. 
Und es gibt noch darauf 

286
00:15:14,480 --> 00:15:18,720
aufbauend eine erweiterte Form 
und die 3 würde ich gerne mal 

287
00:15:18,720 --> 00:15:21,080
jetzt der Reihe nach mit dir 
besprechen und. 

288
00:15:21,080 --> 00:15:23,320
Um einfach n guten Überblick zu 
geben und halt auch immer so n 

289
00:15:23,320 --> 00:15:25,680
bisschen vor und Nachteile und 
Use Cases zu nennen. 

290
00:15:26,000 --> 00:15:29,680
Und ich glaube dann haben wir 
hier im. 

291
00:15:29,680 --> 00:15:32,880
Vorfeld bevor wir jetzt wirklich
in diese 3 Punkte einsteigen, 

292
00:15:33,120 --> 00:15:35,920
würde ich vielleicht noch mal 
ganz kurz n kleinen mini Exkurs 

293
00:15:35,920 --> 00:15:38,320
machen. 
Nur falls weil ich es könnte 

294
00:15:38,320 --> 00:15:41,840
sein, dass 2 bestimmte Begriffe 
fallen innerhalb dieser, wenn 

295
00:15:41,840 --> 00:15:45,440
wir das jetzt durchgehen. 
Und zwar einmal Interface, also 

296
00:15:45,440 --> 00:15:48,480
Schnittstelle und abstrakte 
Klasse, weil wir sind ja jetzt 

297
00:15:48,480 --> 00:15:52,320
wie wie du schon meintest, in 
Objektorientierungsebene und 

298
00:15:52,560 --> 00:15:57,080
damit man einmal vielleicht noch
mal ganz kurz diesen ne, dass 

299
00:15:57,080 --> 00:15:59,600
man dann vielleicht noch mal 
alle abholt, bei denen es 

300
00:15:59,600 --> 00:16:03,360
vielleicht mal so n bisschen ins
Grübeln kommt, so was war noch 

301
00:16:03,360 --> 00:16:05,920
mal ne Schnittstelle und das 
würde ich einmal ganz kurz noch 

302
00:16:05,920 --> 00:16:09,080
mal sagen und dann können wir 
direkt reinstarten also n 

303
00:16:09,080 --> 00:16:11,840
Interface ist im Endeffekt ja 
nichts anderes als eine. 

304
00:16:12,320 --> 00:16:15,960
Sammlung von Methodendeklaration
also, dass du sagst, OK, du hast

305
00:16:15,960 --> 00:16:20,840
jetzt zum Beispiel bei, wenn wir
jetzt bei der Pizza sind bei 

306
00:16:20,840 --> 00:16:23,600
dieser ne, wenn wir jetzt von 
diesem Pizzabeispiel ausgehen, 

307
00:16:23,600 --> 00:16:27,440
dass du einfach sagst sowas wie 
mach Soße drauf, das ist eine 

308
00:16:27,440 --> 00:16:31,280
Funktion wo also ne die die da 
zum Beispiel irgendwie sinnvoll 

309
00:16:31,280 --> 00:16:33,840
wäre, weil du musst ja irgendwie
Soße drauf machen, ne als 

310
00:16:33,840 --> 00:16:37,040
Beispiel und dann hast du 
vielleicht noch andere, aber du 

311
00:16:37,040 --> 00:16:41,400
hast im Endeffekt nur diese 
leeren Hüllen von Methoden, die 

312
00:16:41,400 --> 00:16:44,800
einfach so. 
Für jede Pizza angewandt werden 

313
00:16:44,800 --> 00:16:49,040
müssen und die dann aber für 
jede Pizza selbst implementiert 

314
00:16:49,040 --> 00:16:51,360
werden müssen. 
Also du sagst nur, das muss 

315
00:16:51,360 --> 00:16:54,480
passieren bei der Pizza, also du
musst auf jeden Fall Soße drauf 

316
00:16:54,480 --> 00:16:59,000
tun, wie genau ist bei dem 
Interface nicht festgelegt, das 

317
00:16:59,000 --> 00:17:02,160
heißt du hast im Endeffekt nur 
du weißt nur was passieren soll,

318
00:17:02,240 --> 00:17:05,119
aber du weißt nicht genau was 
passieren soll. 

319
00:17:06,119 --> 00:17:08,800
Also im Einzelnen. 
Und wenn du jetzt sagst, du hast

320
00:17:08,800 --> 00:17:11,680
eine abstrakte Klasse, das ist 
ja ein bisschen ähnlich, kannst 

321
00:17:11,680 --> 00:17:15,640
du ähnlich verwenden, nur dass 
eine abstrakte Klasse zwar auch 

322
00:17:15,640 --> 00:17:19,000
sowas haben kann, wieso eine 
abstrakte Methode wo du sagst 

323
00:17:19,000 --> 00:17:20,880
okay es gibt keine 
Implementierung dafür, aber es 

324
00:17:20,880 --> 00:17:24,640
muss implementiert werden in der
entsprechenden Klasse, aber es 

325
00:17:24,640 --> 00:17:27,319
gibt auch konkrete Methoden, 
also wo wirklich eine 

326
00:17:27,319 --> 00:17:29,720
Implementierung drin ist. 
Und wenn du jetzt zum Beispiel 

327
00:17:29,720 --> 00:17:31,800
das Gleiche mit einer Pizza 
machst kannst. 

328
00:17:31,880 --> 00:17:34,760
Könntest du zum Beispiel sagen, 
wenn du dieses Interface Pizza 

329
00:17:34,760 --> 00:17:37,920
hast, wo du sagst paktros Soße 
drauf, dann müsstest du, wenn du

330
00:17:37,920 --> 00:17:39,920
2 verschiedene Pizzen 
implementiert, also 

331
00:17:39,920 --> 00:17:44,120
implementierst müsstest du bei 
jeder Pizza sagen okay pack mal 

332
00:17:44,120 --> 00:17:47,280
bitte Soße drauf, zum Beispiel 
eine Kelle und bei der anderen 

333
00:17:47,360 --> 00:17:49,360
zum Beispiel auch eine Kelle 
oder 2. 

334
00:17:49,920 --> 00:17:52,600
Wenn es mehr oder weniger sein 
soll, wenn du eine abstrakte 

335
00:17:52,600 --> 00:17:55,360
Klasse nimmst und dieses in 
dieser abstrakten Klasse, dass 

336
00:17:55,520 --> 00:17:57,960
die Methode packsoße drauf hast,
dann. 

337
00:17:57,960 --> 00:18:00,240
Dann könntest du immer 
festlegen, weil wir auch vorhin 

338
00:18:00,240 --> 00:18:01,840
meinten, es ist immer die 
gleiche Menge. 

339
00:18:02,240 --> 00:18:05,760
Sagst du dort einfach, mach mal 
eine Kelle Soße drauf in dieser 

340
00:18:05,920 --> 00:18:10,240
Methode und dann kann quasi eine
Salami Pizza kann dann im 

341
00:18:10,240 --> 00:18:15,520
Endeffekt eine Pizza sein und je
nachdem ob es dann ein Interface

342
00:18:15,520 --> 00:18:20,400
ist oder eine abstrakte Klasse, 
von der ich sag mal die 

343
00:18:20,640 --> 00:18:23,280
entsprechende spezifische Pizza 
ableitet oder erbt. 

344
00:18:24,160 --> 00:18:26,880
Hast du dann sozusagen die 
Möglichkeiten zu sagen, OK, muss

345
00:18:26,880 --> 00:18:29,720
ich das immer selbst 
implementieren oder ist es 

346
00:18:29,720 --> 00:18:31,760
vielleicht schon an der einen 
oder anderen Stelle schon 

347
00:18:31,760 --> 00:18:35,920
vorimplementiert? 
Ja, also den Unterschied 

348
00:18:35,920 --> 00:18:38,360
zwischen Interface und der 
abstrakten Klasse sehen wir dann

349
00:18:38,360 --> 00:18:41,680
auch in den Factory Pattern auch
noch mal genau explizit sag ich 

350
00:18:41,680 --> 00:18:43,680
mal, weil das ist nämlich genau 
der Unterschied zwischen so 

351
00:18:43,680 --> 00:18:46,560
einer einfachen Factory und sag 
ich mal dem offiziellen Factory 

352
00:18:46,560 --> 00:18:49,760
Pattern. 
Ja, aber ja, es ist natürlich 

353
00:18:49,760 --> 00:18:52,520
ein wichtiger Unterschied und 
auch nicht so trivial, aber. 

354
00:18:52,640 --> 00:18:56,080
Also für also wenn man selbst 
halt manchmal so denkt, ja, ist 

355
00:18:56,080 --> 00:18:58,360
ja klar was n Interface ist, was
ne abstrakte Klasse ist. 

356
00:18:58,360 --> 00:19:00,600
Nein, so klar ist das nicht 
gerade am Anfang nicht. 

357
00:19:00,600 --> 00:19:02,320
Deswegen gut, dass du es noch 
mal erwähnt hast. 

358
00:19:02,800 --> 00:19:04,800
Und ich weiß nicht, wie es bei 
dir ist. 

359
00:19:04,800 --> 00:19:07,000
Jedes Mal, wenn ich drüber 
nachdenke, muss ich auch erstmal

360
00:19:07,000 --> 00:19:09,120
wieder drüber nachdenken. 
Also es kommt nicht so wie aus 

361
00:19:09,120 --> 00:19:11,440
der Pistole geschossen, dass ich
sage ja, hier das und das, 

362
00:19:11,440 --> 00:19:14,720
sondern erstmal noch mal kurz im
Kopf differenzieren und dann 

363
00:19:14,960 --> 00:19:17,440
quasi versuchen zu erläutern, 
das ist nämlich gar nicht so 

364
00:19:17,440 --> 00:19:19,720
trivial am Ende. 
Ich find was man sich auf jeden 

365
00:19:19,720 --> 00:19:21,800
Fall merken kann ist n 
Interface, da steckt niemals 

366
00:19:21,800 --> 00:19:24,160
Logik drin. 
Es sagt immer nur, was muss 

367
00:19:24,160 --> 00:19:26,000
passieren, aber nicht, wie es 
passieren muss. 

368
00:19:26,080 --> 00:19:28,120
Und bei einer abstrakten Klasse 
kannst du beides machen. 

369
00:19:28,120 --> 00:19:30,640
Du kannst einmal auf der einen 
Seite sagen, OK, was muss 

370
00:19:30,640 --> 00:19:33,360
passieren und du kannst aber 
auch noch zusätzlich sagen, wie 

371
00:19:33,360 --> 00:19:36,120
soll es denn genau konkret 
passieren, so das ist so n 

372
00:19:36,120 --> 00:19:39,040
bisschen das eigentlich das was 
man damit machen kann. 

373
00:19:39,040 --> 00:19:40,880
Also ich würde sagen ne 
abstrakte Klasse ist halt 

374
00:19:40,880 --> 00:19:44,960
mächtiger als n Interface. 
Ja genau, also in Interface kann

375
00:19:44,960 --> 00:19:47,360
man sich halt merken, ist halt 
so ne Art Vereinbarung, sagen 

376
00:19:47,360 --> 00:19:49,280
wir es mal so, also es ist halt 
ne Definition. 

377
00:19:49,640 --> 00:19:53,880
Damit beide Seiten, die das 
verwenden, also der es erzeugt 

378
00:19:53,880 --> 00:19:57,200
und der es verwenden möchte, 
weiß, was drin sein wird. 

379
00:19:57,280 --> 00:20:01,840
So ne OK, aber dann lass uns 
direkt mal mit dem ersten Anfang

380
00:20:01,840 --> 00:20:04,320
und zwar mit der simple Factory,
weil da kommen jetzt auch 

381
00:20:04,320 --> 00:20:07,120
genauso die Interfaces zum 
Einsatz. 

382
00:20:07,520 --> 00:20:09,440
Also wie gesagt noch mal die 
Anmerkung, Es ist kein 

383
00:20:09,440 --> 00:20:13,920
offizielles Pattern, aber es ist
sehr verbreitet und gerade am. 

384
00:20:14,080 --> 00:20:17,840
Anfang eines Projekts sehr 
einsteigerfreundlich, wenn man 

385
00:20:17,840 --> 00:20:19,840
so schon mal n bisschen was 
strukturieren will, aber 

386
00:20:19,840 --> 00:20:23,600
vielleicht noch nicht so ne 
Riesenkomplexität drin hat, dass

387
00:20:23,600 --> 00:20:25,480
es nicht mehr ausreicht. 
Deswegen ist es eigentlich immer

388
00:20:25,480 --> 00:20:28,480
n ganz guter Start damit 
anzufangen und man kann sich das

389
00:20:28,480 --> 00:20:31,000
so vorstellen, dass man jetzt 
dieses simple Factory hat, also 

390
00:20:31,000 --> 00:20:35,120
eine zentrale Klasse. 
Die eine Methode bereitstellt 

391
00:20:35,120 --> 00:20:38,960
beispielsweise eine Create mit 
einem Eingabeparameter, also zum

392
00:20:38,960 --> 00:20:41,960
Beispiel, wie wir bei der 
Pizzeria hatten, zu sagen, man 

393
00:20:41,960 --> 00:20:46,080
kippt noch rein, welche Pizza ja
zum Beispiel als String kann man

394
00:20:46,080 --> 00:20:47,440
ja machen. 
Ja, wenn du jetzt einfach sagen 

395
00:20:47,440 --> 00:20:52,560
möchtest Salami oder oder ne 
Nummer vom vom vom vom Menü 

396
00:20:52,560 --> 00:20:57,280
sozusagen und daran wird dann 
quasi entschieden was erzeugt 

397
00:20:57,280 --> 00:20:59,920
wird, das heißt diese Create 
gibt dir dann am Ende dein 

398
00:20:59,920 --> 00:21:02,880
Objekt zurück, was du haben 
möchtest, oder? 

399
00:21:03,640 --> 00:21:07,520
N anderer, n anderes Beispiel 
ne, was ich auch schon oft 

400
00:21:07,760 --> 00:21:10,320
gelesen hab und das macht auch 
Sinn, wenn du dir jetzt so zum 

401
00:21:10,320 --> 00:21:13,600
Beispiel vorstellst, du gehst 
Fastfood essen, ja du gehst 

402
00:21:13,600 --> 00:21:15,520
jetzt zu mcdonald's zum 
Beispiel, dann stellst du dich 

403
00:21:15,520 --> 00:21:18,880
ja auch an die Kasse und sagst 
ich hätt gern n Cheeseburger so 

404
00:21:19,200 --> 00:21:22,920
das wird aufgenommen. 
Der Satz Ich hätte gerne einen 

405
00:21:22,920 --> 00:21:25,440
Cheeseburger ist klar, die Küche
weiß, was zu tun ist. 

406
00:21:25,680 --> 00:21:29,520
Ja, zum Beispiel jetzt und so. 
Factory mcdonald's Kitchen ruft 

407
00:21:29,520 --> 00:21:32,640
die Create auf und sagt 
Cheeseburger so, dann geht es in

408
00:21:32,640 --> 00:21:34,640
der Küche zur Sache. 
Dieser Cheeseburger wird 

409
00:21:34,640 --> 00:21:38,400
hergestellt und zwar ist es und 
jetzt kommt ein Interface, ganz 

410
00:21:38,400 --> 00:21:40,480
klar wie n Cheeseburger 
auszusehen hat. 

411
00:21:40,480 --> 00:21:43,120
Ja also dieses Interface wurde 
für den Cheeseburger 

412
00:21:43,120 --> 00:21:46,400
implementiert, das heißt 
Brötchen keine Ahnung Patty. 

413
00:21:46,920 --> 00:21:48,400
Was kommt da? 
Kommt da überhaupt noch ne Gurke

414
00:21:48,400 --> 00:21:51,920
drauf, keine Ahnung, klar das 
war da glaub ich noch nie drauf.

415
00:21:52,160 --> 00:21:55,840
Nee, OK. 
Ja, Käse klar, Käse Käse wär gut

416
00:21:55,840 --> 00:21:58,000
beim Cheeseburger. 
Ich hoffe, dass da Käse drauf 

417
00:21:58,000 --> 00:21:59,880
ist. 
Weißt du zugeklappt eingepackt 

418
00:21:59,880 --> 00:22:03,040
raus, du kriegst das und hast 
deinen wunderbaren Cheeseburger.

419
00:22:03,680 --> 00:22:07,240
Vorteil an dieser 
Implementierung ist, dass es 

420
00:22:07,240 --> 00:22:09,560
halt schnell, einfach und 
übersichtlich erstmal ist. 

421
00:22:09,560 --> 00:22:13,040
Ne, weil du hast dann diese eine
Funktion und du kannst dir 

422
00:22:13,040 --> 00:22:15,600
tausende Cheeseburger erstellen,
damit ne du sagst ihn immer 

423
00:22:15,600 --> 00:22:17,680
wieder. 
Das hatte ich gerade gesagt. 

424
00:22:18,400 --> 00:22:21,920
Ja, mcdonald's Kitchen Punkt 
create gibt es Cheeseburger als 

425
00:22:21,920 --> 00:22:26,080
Parameter rein und du kriegst n 
Cheeseburger so der Nachteil ist

426
00:22:26,080 --> 00:22:28,320
ist genau das was du nämlich 
jetzt gerade gesagt hast. 

427
00:22:28,320 --> 00:22:30,880
Aber jetzt möchte ich aber n 
normalen Hamburger jetzt möchte 

428
00:22:30,880 --> 00:22:33,520
ich oh Mann jetzt komm ich ins 
Schwimmen was gibt es bei 

429
00:22:33,520 --> 00:22:36,520
mcdonald's? 
Ja super super Mcchicken oder 

430
00:22:36,520 --> 00:22:39,760
wie die heißen ja also es gibt 
halt ziemlich viele Burger. 

431
00:22:40,160 --> 00:22:43,080
So, und da kommt nämlich dann 
der Nachteil, weil wir auch bei 

432
00:22:43,080 --> 00:22:45,360
den Getränkeautomaten meinten, 
man kann das ja zum Beispiel mit

433
00:22:45,360 --> 00:22:49,440
einem Switch machen, nur dann 
kommst du halt relativ schnell 

434
00:22:49,440 --> 00:22:52,160
bei steigender Komplexität in 
die Switch. 

435
00:22:52,160 --> 00:22:55,120
Hölle also weil du einfach alle 
Fälle. 

436
00:22:55,520 --> 00:22:58,960
Sauber unterscheiden musst, weil
du ja immer explizit diesen 

437
00:22:58,960 --> 00:23:02,560
einen Burger rausgibst und 
dieser eine Burger implementiert

438
00:23:02,560 --> 00:23:05,840
quasi deine Schnittstelle wie es
aussehen soll und definiert. 

439
00:23:05,840 --> 00:23:09,520
Das ist n Cheeseburger, das ist 
NN Big Mac gibt es n Big Mac so 

440
00:23:09,520 --> 00:23:14,080
Big Mac oder oder oder n Chicken
Burger oder so ne ich find das 

441
00:23:14,080 --> 00:23:16,200
heißt. 
Ich muss das jeden type erkennen

442
00:23:16,200 --> 00:23:18,880
ne also ich find es gut, dass du
sagst auch es gibt n Burger 

443
00:23:18,880 --> 00:23:22,400
raus, weil am Ende sagst du ja 
ne irgendwie die Küche. 

444
00:23:22,760 --> 00:23:25,640
Create und dann zum Beispiel 
Cheeseburger, Hamburger oder was

445
00:23:25,640 --> 00:23:28,160
auch immer. 
Was am Ende rauskommt ist ja ein

446
00:23:28,160 --> 00:23:33,040
Burger, ne, du sagst ja du 
kriegst einen Burger und was 

447
00:23:33,040 --> 00:23:37,120
aber quasi der also du kriegst n
Cheeseburger oder n Hamburger 

448
00:23:37,120 --> 00:23:39,800
der aber im Kern n Burger ist ne
und wenn wir jetzt zum Beispiel 

449
00:23:39,800 --> 00:23:42,800
davon ausgehen, dass wir dann am
Ende n Interface, also Burger 

450
00:23:42,800 --> 00:23:45,280
ist n Interface und du kannst 
halt sagen ja OK, der 

451
00:23:45,280 --> 00:23:50,440
Cheeseburger muss halt alle 
Methoden vom vom Burger quasi 

452
00:23:50,440 --> 00:23:52,720
implementieren. 
So, das heißt du weißt auf jeden

453
00:23:52,720 --> 00:23:56,240
Fall auf einen Cheeseburger 
kommt, also dafür brauchst du 

454
00:23:56,400 --> 00:24:00,240
Brötchen, dafür brauchst du ein 
Patty, dafür brauchst du Soße 

455
00:24:00,240 --> 00:24:02,480
zum Beispiel und das ist bei 
einem Hamburger genauso. 

456
00:24:02,480 --> 00:24:06,960
Du brauchst auf jeden Fall auch 
wieder ein, also ein Brötchen 

457
00:24:06,960 --> 00:24:09,600
und du brauchst auch wieder ein 
Patty und du brauchst auch Soße,

458
00:24:09,600 --> 00:24:13,040
es ist vielleicht was anderes je
nach Burger und das ist halt 

459
00:24:13,040 --> 00:24:15,840
genau dann sozusagen. 
Dass du zwar sagst, OK, das muss

460
00:24:15,840 --> 00:24:19,680
alles da sein, aber es muss 
einzeln implementiert werden in 

461
00:24:19,680 --> 00:24:24,160
den entsprechenden expliziten 
Klassen dann ne, also der 

462
00:24:24,240 --> 00:24:27,680
Cheeseburger weiß nur was 
passieren muss, aber wie genau, 

463
00:24:27,680 --> 00:24:29,360
das musst du im Cheeseburger 
festlegen. 

464
00:24:29,520 --> 00:24:32,560
So ne genau. 
Und da haben wir nämlich genau 

465
00:24:32,560 --> 00:24:34,720
das Problem. 
Wenn du jetzt sehr viele Burger 

466
00:24:34,720 --> 00:24:35,920
hast. 
Ja, also ich find das mcdonald's

467
00:24:35,920 --> 00:24:37,720
Beispiel ist gar nicht so 
schlecht, weil das kann man sich

468
00:24:37,720 --> 00:24:40,240
auch gut vorstellen, weil es 
noch n bisschen komplexer ist 

469
00:24:40,240 --> 00:24:42,960
als ne Pizza sag ich mal. 
Also komplexer im Sinne von der 

470
00:24:42,960 --> 00:24:46,320
Variantenvielfalt. 
Wenn du jetzt nämlich wirklich 

471
00:24:46,320 --> 00:24:49,600
grundverschiedene Burger hast 
und du gehst, aber das mit so 

472
00:24:49,600 --> 00:24:53,160
einem simple Factory Pattern 
Ansatz so wirklich ganz simpel 

473
00:24:53,160 --> 00:24:56,160
gehalten mit einfach so einer 
create Methode, ja dann hast du 

474
00:24:56,160 --> 00:24:58,680
halt das Ding, dass du wie du 
meintest, das Interface immer 

475
00:24:58,680 --> 00:25:01,200
neu implementieren musst. 
Ne, wie wird dieser Burger 

476
00:25:01,200 --> 00:25:03,000
hergestellt? 
Na ja, ich brauch das Brötchen 

477
00:25:03,000 --> 00:25:05,160
OK ich hol mir das Brötchen. 
Was brauch ich jetzt für n 

478
00:25:05,160 --> 00:25:07,760
Patty? 
Ja, Chicken Beef gibt es noch 

479
00:25:07,760 --> 00:25:10,040
was drittes? 
Nee ich glaub die beiden so, da 

480
00:25:10,040 --> 00:25:11,720
musst du da schon mal 
entscheiden ne und das muss ja 

481
00:25:11,720 --> 00:25:13,920
jeder Bürger für sich 
implementieren, damit der am 

482
00:25:13,920 --> 00:25:15,800
Ende dem entspricht wie er 
gedacht ist. 

483
00:25:15,800 --> 00:25:19,040
Sozusagen ne richtig und da 
merkt man schon das ist doch 

484
00:25:19,040 --> 00:25:24,000
viel doppelte Arbeit, ja. 
Wieso soll ich komplett neu 

485
00:25:24,000 --> 00:25:25,920
definieren, wie n Cheeseburger 
aussieht? 

486
00:25:25,920 --> 00:25:28,640
Wenn n. 
Hier gibt es doch auch so mit 

487
00:25:28,640 --> 00:25:32,200
Jalapenos so ne Chili cheese sag
ich mal ne wenn der doch 

488
00:25:32,200 --> 00:25:34,240
eigentlich der gleiche Burger 
also geh ich jetzt mal von aus 

489
00:25:34,240 --> 00:25:36,800
der gleiche Burger ist nur, dass
du nur noch n paar kleine 

490
00:25:36,800 --> 00:25:39,600
Jalapenos da drauf legst. 
Weißt du da muss ich das doch 

491
00:25:39,600 --> 00:25:42,480
nicht komplett neu definieren, 
wenn das der der gleiche Burger 

492
00:25:42,480 --> 00:25:45,600
eigentlich im Kern ist. 
So und da merkt man schon hm. 

493
00:25:45,760 --> 00:25:47,760
Das skaliert doch nicht. 
Also wenn ich jetzt wirklich ne 

494
00:25:47,760 --> 00:25:51,120
riesen burgerkarte hab, das wird
nicht skalieren so ne und da ist

495
00:25:51,120 --> 00:25:54,760
nämlich dann auch der Nachteil 
bei der Simple Factory, dass man

496
00:25:54,760 --> 00:25:58,080
sagen kann, bei wenig 
Variantenvielfalt ist es schnell

497
00:25:58,080 --> 00:26:00,880
und einsteigerfreundlich 
implementiert und ausreichend 

498
00:26:00,880 --> 00:26:05,160
völlig okay zu starten, weil 
Stichwort refactoring wenn du 

499
00:26:05,160 --> 00:26:08,560
merkst, ah nee, irgendwie mill 
ich meinen Code jetzt doch zu, 

500
00:26:08,560 --> 00:26:11,240
also das ist jetzt anstrengend, 
da diese ganzen Cases zu 

501
00:26:11,240 --> 00:26:13,760
unterscheiden, dann kann ich ja 
immer noch. 

502
00:26:14,160 --> 00:26:18,000
Refactan und vielleicht auf das 
eigentliche Factory Pattern 

503
00:26:18,000 --> 00:26:21,120
kommen und das würde ich jetzt 
gerne mit dir besprechen, um 

504
00:26:21,120 --> 00:26:23,160
einfach auch da mal den 
Unterschied zu zeigen und 

505
00:26:23,160 --> 00:26:26,800
welchen Mehrwert es bringt, auch
wenn es natürlich Anmerkung 

506
00:26:27,920 --> 00:26:29,680
nicht ganz so 
einsteigerfreundlich ist, weil 

507
00:26:29,680 --> 00:26:31,120
es einfach ein bisschen mehr 
Aufwand hat. 

508
00:26:31,280 --> 00:26:35,200
Ja, also bisschen mehr Overhead 
an Code hat am Anfang ja ja auf.

509
00:26:35,840 --> 00:26:37,840
Jeden Fall. 
Also wenn ich jetzt zum Beispiel

510
00:26:37,840 --> 00:26:41,520
dieses Factory pattern, so wie 
es vielleicht dann auch 

511
00:26:41,520 --> 00:26:46,080
angedacht ist, nehme. 
Würde ich einmal kurz vielleicht

512
00:26:46,560 --> 00:26:49,560
direkt den Unterschied zum zum 
simple Pattern mit dem Burgern 

513
00:26:49,560 --> 00:26:51,320
darstellen? 
Ne, weil wenn du dir jetzt zum 

514
00:26:51,320 --> 00:26:55,840
Beispiel überlegst, du hast in 
in diesem Burger, den du haben 

515
00:26:55,840 --> 00:26:57,720
möchtest, du meintest ja 
Cheeseburger und Chili 

516
00:26:57,720 --> 00:27:02,080
Cheeseburger ne, also es klingt 
ja schon fast gleich und bei dem

517
00:27:02,480 --> 00:27:04,560
wenn wir jetzt noch mal dieses 
dieses Beispiel mit dem 

518
00:27:04,560 --> 00:27:08,000
Interface haben, dann steht ja 
in in dem Interface drin, du 

519
00:27:08,000 --> 00:27:11,200
brauchst ein Brötchen. 
So, und dieses Brötchen musst du

520
00:27:11,200 --> 00:27:13,760
ja dann sozusagen im 
Cheeseburger definieren. 

521
00:27:13,760 --> 00:27:16,720
Also ne, du brauchst ein 
Brötchen, musst du da in ne 

522
00:27:16,720 --> 00:27:19,040
Logik reinpacken wie zum 
Beispiel Return? 

523
00:27:20,000 --> 00:27:22,560
Weiß nicht simple Bun oder so 
ne, also ein ganz normales 

524
00:27:22,560 --> 00:27:26,160
Brötchen und das gleich diesen 
gleichen, exakt gleichen Code 

525
00:27:26,320 --> 00:27:29,720
musst du ja noch mal im Chili 
Cheeseburger definieren, das 

526
00:27:29,720 --> 00:27:32,080
heißt du hast ja eigentlich 
quasi ne Code dopplung, die du 

527
00:27:32,080 --> 00:27:33,520
eigentlich nicht doppelt 
brauchst. 

528
00:27:33,680 --> 00:27:36,880
So und das bringt aber nun mal 
jetzt sozusagen so ein Interface

529
00:27:36,880 --> 00:27:39,920
mit sich, wenn du sozusagen ne 
Factory über so ein Interface 

530
00:27:40,080 --> 00:27:43,520
nutzt, ne? 
So ein simple Factory. 

531
00:27:43,520 --> 00:27:46,640
Wenn du jetzt aber wirklich 
diese diese Factory patter 

532
00:27:46,640 --> 00:27:49,200
nimmst und sagst an der Stelle 
okay wir nehmen jetzt aber eine 

533
00:27:49,200 --> 00:27:53,240
abstrakte Klasse an dieser 
Stelle, dann können wir bei 

534
00:27:53,240 --> 00:27:56,560
einem sagen du hast einen Chili 
Cheeseburger und du hast einen 

535
00:27:56,560 --> 00:28:00,800
Cheeseburger und das Ganze hat 
eine abstrakte Klasse, von der 

536
00:28:00,800 --> 00:28:05,840
geerbt wird sozusagen, die ist 
einfach ein Burger und dieser 

537
00:28:05,840 --> 00:28:09,480
Burger hat nimm ein Brötchen und
ich. 

538
00:28:09,520 --> 00:28:12,680
In dieser Burger Klasse, in 
dieser abstrakten Klasse ist 

539
00:28:12,680 --> 00:28:16,080
schon definiert, dass du für 
deinen Burger, für die also 

540
00:28:16,080 --> 00:28:19,200
einmal den Cheeseburger und den 
Chili Cheeseburger jeweils das 

541
00:28:19,200 --> 00:28:21,200
normale oder das einfache 
Brötchen nimmst. 

542
00:28:21,680 --> 00:28:24,640
Und damit hast du diese 
Implementierung schon in der 

543
00:28:24,880 --> 00:28:28,720
abstrakten Klasse drin und musst
es nicht zweimal im Cheeseburger

544
00:28:28,720 --> 00:28:31,040
und im Chili Cheeseburger 
sozusagen implementieren. 

545
00:28:31,840 --> 00:28:34,640
Und das hilft dann halt 
sozusagen bestimmte. 

546
00:28:35,360 --> 00:28:37,920
Eigenschaften schon 
zusammenzufassen, um halt eben 

547
00:28:37,920 --> 00:28:40,280
diese Codeduplikation zu 
vermeiden. 

548
00:28:40,280 --> 00:28:44,040
Wie du meintest, weil stell dir 
vor, du hast n burgerrestaurant,

549
00:28:44,040 --> 00:28:47,840
ne was du jetzt in in weiß ich 
irgendwie programmierst in einem

550
00:28:47,840 --> 00:28:51,440
Game oder so wo immer der 
Gleiche es sind immer nur die 

551
00:28:51,440 --> 00:28:53,840
gleichen Burgerbrötchen ne du 
hast niemals andere 

552
00:28:53,840 --> 00:28:55,520
burgerbrötchen, da macht es 
keinen Sinn. 

553
00:28:55,960 --> 00:28:59,200
In 20 Bürgern beispielsweise 
wirklich 20 mal den gleichen 

554
00:28:59,200 --> 00:29:00,640
Code zu machen. 
Ich mein, da kommt man ja 

555
00:29:00,640 --> 00:29:02,960
relativ schnell hin und denkt 
sich so okay irgendwie müsste 

556
00:29:02,960 --> 00:29:04,640
ich das ja vielleicht 
vereinheitlichen können. 

557
00:29:04,640 --> 00:29:07,480
Genau, nimm ne abstrakte Klasse 
und kein Interface an der Stelle

558
00:29:08,640 --> 00:29:11,280
um das jetzt mal so direkt im 
Vergleich zu sehen, ne. 

559
00:29:12,440 --> 00:29:14,600
Genau. 
Und dann dann quasi alle, die 

560
00:29:14,600 --> 00:29:17,200
dann so richtig auf Vererbungen 
in der Objektorientierung 

561
00:29:17,200 --> 00:29:19,520
stehen, die können das natürlich
bis auf die Spitze treiben, dass

562
00:29:19,520 --> 00:29:22,800
du sagst, ich hab ne klasse 
Burger, die ist abstrakt, ne und

563
00:29:22,800 --> 00:29:25,840
dann gibt es n Cheeseburger und 
den kann ich auch noch mal 

564
00:29:25,840 --> 00:29:28,440
weiter vererben zum Chili 
Cheeseburger, der eigentlich nur

565
00:29:28,480 --> 00:29:30,160
n Cheeseburger ist, wo ich am 
Ende halt wie gesagt noch 

566
00:29:30,160 --> 00:29:33,160
lalapenos drauf mache oder 
irgendeinen anderen Burger, wo 

567
00:29:33,160 --> 00:29:35,280
auf einmal Salat und Tomate 
drauf ist oder irgendwie so. 

568
00:29:35,640 --> 00:29:40,320
Also du kannst das ja immer 
weiter Kapseln sozusagen und das

569
00:29:40,320 --> 00:29:43,400
Factory Pattern dann halt so 
richtig ins Spiel bringen, sag 

570
00:29:43,400 --> 00:29:45,520
ich mal. 
Aber ich find n anderes 

571
00:29:45,520 --> 00:29:48,480
Gedankenspiel dabei auch noch 
gut, um sich das noch mal 

572
00:29:48,480 --> 00:29:51,360
vorzustellen, wofür so n Factory
Pattern auch gut ist. 

573
00:29:51,680 --> 00:29:54,160
Wir haben ja jetzt gesagt, du 
hast n burgerladen ja, 

574
00:29:55,120 --> 00:30:00,320
mcdonald's als Beispiel, jetzt 
ist mcdonald's vielleicht sehr 

575
00:30:00,320 --> 00:30:03,600
standardisiert. 
Länderübergreifend, so wie ich 

576
00:30:03,600 --> 00:30:05,480
es jedenfalls kenne. 
Also wahrscheinlich wird es 

577
00:30:05,480 --> 00:30:07,440
schon Unterschiede geben, auch 
wahrscheinlich in den, es ist ja

578
00:30:07,440 --> 00:30:09,520
irgendwo n Franchise am Ende, 
das heißt du hast wahrscheinlich

579
00:30:09,520 --> 00:30:12,440
auch n bisschen andere Karten 
oder Aktionen whatever aber es 

580
00:30:12,440 --> 00:30:15,200
ist schon so standardisiert, 
dass ich glaub ich würd ich 

581
00:30:15,200 --> 00:30:16,880
jetzt mal sagen, so n 
cheeseburger. 

582
00:30:17,960 --> 00:30:19,760
In fast jedem Land gleich ist 
ne. 

583
00:30:19,920 --> 00:30:22,880
Das heißt, das wäre ja auch 
wieder so n bisschen Richtung 

584
00:30:22,880 --> 00:30:25,200
Simple Factory, auch wenn es 
halt wie gesagt zu viele 

585
00:30:25,200 --> 00:30:27,960
verschiedene Burger gibt, aber 
da würde das ja noch so halbwegs

586
00:30:27,960 --> 00:30:30,240
funktionieren zu sagen, Hey 
Cheeseburger ist doch immer 

587
00:30:30,240 --> 00:30:33,360
gleich, ja brauch ich es auch 
wirklich nur einmal machen, aber

588
00:30:33,360 --> 00:30:35,800
wenn man das n bisschen 
allgemeiner formuliert und ich 

589
00:30:35,800 --> 00:30:40,280
hab jetzt einfach n Burger ne 
Burger Kette oder n Burger laden

590
00:30:40,280 --> 00:30:43,920
ne wo ich einfach gut Burger 
essen gehen kann ja dann sieht 

591
00:30:43,920 --> 00:30:48,040
ja dieser Laden oder? 
Sagen wir mal so, ich möchte 

592
00:30:48,040 --> 00:30:50,480
einfach einen Burger bestellen 
und ich gehe jetzt in 

593
00:30:50,480 --> 00:30:54,080
verschiedenen Ländern in einen 
entsprechenden Laden und kaufe 

594
00:30:54,080 --> 00:30:58,320
mir einen Burger, dann sieht er 
ja natürlich beispielsweise im 

595
00:30:58,320 --> 00:31:02,440
asiatischen Raum anders aus als 
im in der USA zum Beispiel ja, 

596
00:31:02,440 --> 00:31:04,400
in der USA ist die 
Wahrscheinlichkeit ja schon 

597
00:31:04,400 --> 00:31:06,720
groß, sowas Big Mac Artiges zu 
bekommen. 

598
00:31:08,400 --> 00:31:11,600
In im asiatischen Raum 
wahrscheinlich eher irgendwas 

599
00:31:11,600 --> 00:31:14,080
asiatisch angehauchtes, ja 
vielleicht irgendwie so mit 

600
00:31:14,080 --> 00:31:17,680
tiriyaki Soße in Japan oder so. 
Keine Ahnung, was geiles halt so

601
00:31:17,680 --> 00:31:21,360
ne, aber am Ende sind beides 
Burger, sind aber grundlegend 

602
00:31:21,360 --> 00:31:23,040
verschieden. 
Also wie willst du jetzt 

603
00:31:23,040 --> 00:31:25,920
anfangen mit einer simple 
Factory das alles abzubilden? 

604
00:31:26,160 --> 00:31:29,360
Das heißt da kommst du halt 
jetzt zu den offiziellen Pattern

605
00:31:29,360 --> 00:31:32,080
zu sagen es gibt ne abstrakte 
Burgerklasse ne es gibt 

606
00:31:32,080 --> 00:31:35,600
Grundeigenschaften eines 
Burgers, aber je nach Land. 

607
00:31:36,480 --> 00:31:39,040
Sind die Spezifikationen 
obendrauf anders? 

608
00:31:39,200 --> 00:31:42,200
Ja, für diesen Burgerladen, das 
heißt, meine Factory ändert sich

609
00:31:42,200 --> 00:31:45,360
dementsprechend auch oder die 
Burger, die ich damit erstellen 

610
00:31:45,360 --> 00:31:48,040
kann, dass ich zum Beispiel 
sagen kann, hey, ich hab ne 

611
00:31:48,040 --> 00:31:52,040
Factory und ich möchte jetzt n 
Burger und ich bin in Japan zum 

612
00:31:52,040 --> 00:31:54,960
Beispiel und dann kriegst du 
halt deinen teriyaki Burger, ja 

613
00:31:54,960 --> 00:31:57,440
oder ich sag, ich bin jetzt in 
der USA und Du kriegst halt n 

614
00:31:57,440 --> 00:32:01,360
Big Mac so aber unter der Haube 
sind das abstrakte Burger, die 

615
00:32:01,600 --> 00:32:05,280
selbst implementieren zum 
Beispiel deine Big Mac Klasse 

616
00:32:05,280 --> 00:32:08,400
Teriyaki Burger Klasse. 
Ich hab keinen besseren Namen, 

617
00:32:08,640 --> 00:32:12,160
sorry, und da hast du jetzt den 
Vorteil, dass die eigentliche 

618
00:32:12,160 --> 00:32:16,960
Erstellung ja wie das Objekt am 
Ende aussieht, dann in deinen 

619
00:32:16,960 --> 00:32:19,880
Subklassen ist. 
Das heißt, die Factory hat jetzt

620
00:32:19,880 --> 00:32:25,120
nicht mehr die Logik sowas wie 
OK, das Interface ich returne 

621
00:32:25,120 --> 00:32:27,840
jetzt das Interface mit den und 
den Funktionen oder den und den 

622
00:32:27,840 --> 00:32:32,800
Werten ja, sondern ich geb jetzt
ne Subklasse zurück wie Big Mac 

623
00:32:32,800 --> 00:32:36,080
Burger. 
Ja, weil die Factory wurde jetzt

624
00:32:36,080 --> 00:32:40,000
aufgerufen, mit Burger in der 
USA, Mhm so und dann geb ich ne 

625
00:32:40,000 --> 00:32:43,520
Big Mac Klasse zurück und die 
Klasse selbst definiert jetzt 

626
00:32:43,520 --> 00:32:45,760
wie der Burger ist und nach 
außen ist es dann halt wirklich 

627
00:32:45,760 --> 00:32:47,360
nur noch dieser abstrakte 
Burger. 

628
00:32:47,920 --> 00:32:51,800
Erstmal ja so und das ist halt 
der große Vorteil, dass du halt 

629
00:32:51,800 --> 00:32:56,400
so komplexe Abläufe damit dann 
auch implementieren kannst. 

630
00:32:56,400 --> 00:33:00,560
Zum Beispiel sowas wie. 
Länderabhängig Länderabhängig 

631
00:33:00,560 --> 00:33:04,120
ist, weißt du ja. 
Ich meine, das ist ja, wenn man 

632
00:33:04,120 --> 00:33:06,280
sich das zum Beispiel noch mal 
im Vergleich vorstellt, und du 

633
00:33:06,280 --> 00:33:11,760
hast jetzt ein bisschen ein 
leicht abstrakteres Beispiel, du

634
00:33:11,760 --> 00:33:13,800
hast jetzt zum Beispiel ein 
Interface, ne, weil du ja 

635
00:33:13,800 --> 00:33:16,240
meintest, das macht damit nicht 
so viel Sinn und stell dir vor, 

636
00:33:16,240 --> 00:33:20,080
du hast am Ende ein Interface, 
wo alle Objekte eigentlich nur 

637
00:33:20,080 --> 00:33:23,920
eine Methode teilen, die sie auf
jeden Fall alle haben, und dann 

638
00:33:23,920 --> 00:33:27,440
aber zum Beispiel Objekt 1, ne, 
was du instanzieren möchtest. 

639
00:33:27,720 --> 00:33:33,120
Hat dann aber 5 Funktionen von 
der von dem Interface noch und 

640
00:33:33,280 --> 00:33:36,160
klasse 2 noch mal 5 andere. 
Das heißt du hast in deiner in 

641
00:33:36,160 --> 00:33:39,120
deinem Interface 11 Funktionen, 
aber für die eine Klasse 

642
00:33:39,120 --> 00:33:42,800
brauchst du eigentlich nur die 
Hälfte und für die andere auch n

643
00:33:42,800 --> 00:33:45,080
bisschen mehr als die Hälfte. 
Du hast also ne minimale 

644
00:33:45,080 --> 00:33:47,600
Schnittmenge und denkst dir so, 
warum hab ich eigentlich n 

645
00:33:47,600 --> 00:33:50,480
Interface mit so vielen 
Funktionen die ich aber am Ende 

646
00:33:50,480 --> 00:33:53,560
gar nicht implementieren muss? 
Also du musst sie quasi 

647
00:33:53,560 --> 00:33:56,040
implementieren, was sind 
leerimplementierungen dann und? 

648
00:33:56,120 --> 00:33:58,160
Und du denkst ja so, die brauch 
ich da ja gar nicht drin. 

649
00:33:58,160 --> 00:34:01,240
Ne und das macht es dann an der 
Stelle irgendwann einfach nicht 

650
00:34:01,240 --> 00:34:04,320
mehr sinnvoll, sozusagen so n 
simple Factory Pattern zu 

651
00:34:04,320 --> 00:34:06,800
verwenden, sondern dann halt 
eben dieses Standard Factory 

652
00:34:06,800 --> 00:34:11,080
Pattern zu nutzen. 
Ne und ich find das ja, wenn wir

653
00:34:11,080 --> 00:34:12,560
jetzt das Ganze noch mal 
vielleicht n bisschen 

654
00:34:12,719 --> 00:34:16,800
technischer erklären, weil mir 
bringt das manchmal auch 

655
00:34:17,040 --> 00:34:20,560
irgendwie was, wenn ich mir dann
denke so OK, ja gut, wann 

656
00:34:20,560 --> 00:34:23,920
implementier ich denn jetzt mal 
ne ne Burger factory, weißt du? 

657
00:34:25,520 --> 00:34:27,400
So, wo wird denn das? 
Überhaupt, ich hab jetzt genug 

658
00:34:27,400 --> 00:34:32,159
über Burger geredet, ich hab 
erstmal Hunger, nur Pause ein. 

659
00:34:33,040 --> 00:34:36,280
Aber zum Beispiel, wenn man 
jetzt sagt, du hast einen. 

660
00:34:36,280 --> 00:34:38,719
Ich bestell auch Grad nebenbei. 
Was willst du auch was? 

661
00:34:39,520 --> 00:34:40,560
Ja komm. 
N. 

662
00:34:40,560 --> 00:34:42,400
Cheeseburger und n Chili cheese 
würde ich gerne lesen. 

663
00:34:44,960 --> 00:34:47,679
Wenn du jetzt aber pass auf wenn
du jetzt sagst du hast ne UI 

664
00:34:47,679 --> 00:34:50,800
oder so ne und du sagst ich 
möchte jetzt du hast ne Factory 

665
00:34:51,600 --> 00:34:53,199
wie wie du sie gerade 
beschrieben hast. 

666
00:34:54,000 --> 00:34:57,680
Mit einem Button so und dann 
möchtest du einfach nur zum 

667
00:34:57,680 --> 00:35:01,040
Beispiel einen Button haben und 
jetzt ist aber die Frage, auf 

668
00:35:01,040 --> 00:35:05,520
welchem Betriebssystem hältst du
dich denn gerade auf, weil jeder

669
00:35:05,520 --> 00:35:08,000
weiß das ja, dass zum Beispiel 
auf einem Mac das Ganze 

670
00:35:08,000 --> 00:35:11,040
vielleicht ein bisschen anders 
aussieht als auf einem Windows 

671
00:35:11,040 --> 00:35:14,600
PC, die UI oder vielleicht auch 
bei einem Linux oder? 

672
00:35:14,600 --> 00:35:17,680
Und damit du dann aber im 
Endeffekt sagst, ich möchte nur 

673
00:35:17,680 --> 00:35:20,640
diesen Button, aber unabhängig 
davon, also ich möchte ja gar 

674
00:35:20,640 --> 00:35:23,640
nicht, mir ist es egal welche 
auf welchem Betriebssystem ich 

675
00:35:23,640 --> 00:35:27,600
mich befinde, diese Factory soll
mir einfach den richtigen Button

676
00:35:27,600 --> 00:35:30,080
zurückgeben, den ich dann 
einfach meine UI einsetzen kann.

677
00:35:31,120 --> 00:35:35,960
Ja, das ist ein gutes Beispiel, 
weil ja der Button unabhängig 

678
00:35:35,960 --> 00:35:39,440
vom Betriebssystem am Ende die 
gleiche Funktion haben wird oder

679
00:35:39,440 --> 00:35:42,480
die gleichen Fähigkeiten. 
Attribute nenn ich es mal ne. 

680
00:35:43,280 --> 00:35:47,360
Aber ich natürlich im 
Betriebssystem Style bleiben 

681
00:35:47,360 --> 00:35:48,800
möchte. 
Gerade wenn ich jetzt so Cross 

682
00:35:48,800 --> 00:35:50,480
Plattformen entwickle. 
Ja und ich sage, ich habe jetzt 

683
00:35:50,480 --> 00:35:52,240
zum Beispiel ne Desktop 
application und ich möchte die 

684
00:35:52,240 --> 00:35:55,040
aber auf eingängigen 
Betriebssystem anbieten können, 

685
00:35:55,120 --> 00:35:58,120
dann macht es natürlich Sinn wie
du gerade meintest erstmal zu 

686
00:35:58,120 --> 00:36:01,120
gucken auf welchem 
Betriebssystem läuft diese 

687
00:36:01,120 --> 00:36:05,240
Anwendung und dementsprechend 
Style ich sie oder baue sie wie 

688
00:36:05,240 --> 00:36:08,240
auch immer an welchem Step wir 
jetzt sind ja und? 

689
00:36:08,600 --> 00:36:11,040
Das ist halt n cooles Beispiel, 
weil unter der Haube ist es ja 

690
00:36:11,040 --> 00:36:13,160
der gleiche Button. 
Am Ende ne, der hat dann zum 

691
00:36:13,160 --> 00:36:15,240
Beispiel irgendein Callback, 
wenn du ihn drückst der 

692
00:36:15,240 --> 00:36:17,200
implementiert werden kann und 
das hat ja bei allen 

693
00:36:17,200 --> 00:36:19,440
Betriebssystemen nur dass er 
halt vielleicht vom Styling 

694
00:36:19,440 --> 00:36:20,680
anders aussieht. 
Richtig. 

695
00:36:20,680 --> 00:36:23,120
Und dann hast du sozusagen das 
Styling, ist unterschiedlich in 

696
00:36:23,120 --> 00:36:25,680
den eigenen Klassen, aber dieser
Callback, wie du ihn zum 

697
00:36:25,680 --> 00:36:27,520
Beispiel gerade genannt hast, 
oder die Funktionalität, die 

698
00:36:27,520 --> 00:36:29,040
dahinter steht n bisschen 
abstrakter. 

699
00:36:29,560 --> 00:36:31,560
Ist dann halt eben in der 
Basisklasse vertreten. 

700
00:36:31,560 --> 00:36:34,400
Ne und und weil es ist ja immer 
das Gleiche dann für diesen 

701
00:36:34,400 --> 00:36:36,560
entsprechenden Button, sagst zum
Beispiel N submit Button und 

702
00:36:36,560 --> 00:36:38,640
dann kriegst du halt wirklich 
diesen submit Button 

703
00:36:38,640 --> 00:36:41,880
unterschiedlich gestylt, je 
nachdem Betriebssystem aber die 

704
00:36:41,880 --> 00:36:45,840
gleiche Funktionalität, ne das 
ist auf jeden Fall dann der Sinn

705
00:36:45,840 --> 00:36:48,480
dahinter. 
Das heißt, um das noch mal 

706
00:36:48,480 --> 00:36:51,120
technisch sich vorzustellen, man
hat dann im Code zum Beispiel ne

707
00:36:51,120 --> 00:36:54,560
Klassenabstrakte Klasse Button 
und die Implementierung davon 

708
00:36:54,560 --> 00:36:57,280
wäre dann zum Beispiel N Windows
Button oder N Linux Button. 

709
00:36:57,600 --> 00:37:00,880
Ja, und die Factory gibt dir den
abhängig von dem Betriebssystem,

710
00:37:00,880 --> 00:37:03,440
auf dem du bist. 
N Windows Button oder N Linux 

711
00:37:03,440 --> 00:37:05,680
Button um es so n bisschen 
konkreter zu machen. 

712
00:37:05,920 --> 00:37:08,200
Und ja da sieht man ja 
eigentlich schon die die 

713
00:37:08,200 --> 00:37:10,800
Vorteile einer Factory. 
Ja also du hast halt diese 

714
00:37:10,800 --> 00:37:14,280
Austauschbarkeit, ne, das heißt 
mit jeder Subklasse die ich 

715
00:37:14,280 --> 00:37:16,880
implementiere kriege ich halt 
auch so ne neue Implementierung 

716
00:37:16,880 --> 00:37:19,040
rein ohne die anderen anrühren 
zu müssen. 

717
00:37:19,040 --> 00:37:22,400
Ganz wichtiger Punkt ja wenn ich
das Styling am Linux Button 

718
00:37:22,400 --> 00:37:24,560
ändern muss ich nichts am 
Windows Button machen weil der 

719
00:37:24,560 --> 00:37:26,960
soll ja auch bleiben wie er ist.
Das heißt, ich muss da am Code 

720
00:37:26,960 --> 00:37:30,640
nicht drin rumrühren und kann 
halt potenziell Fehler einbauen.

721
00:37:30,880 --> 00:37:35,280
Das heißt, die Austauschbarkeit 
ist halt auch gegeben, ne, wenn 

722
00:37:35,360 --> 00:37:37,440
zum Beispiel der Linux Button 
einfach ganz anders aussehen 

723
00:37:37,440 --> 00:37:39,920
soll oder vielleicht gar nicht 
mehr drin sein soll, oder dazu 

724
00:37:39,920 --> 00:37:43,200
kommt, du kannst es halt einfach
nebeneinander halten sozusagen, 

725
00:37:43,200 --> 00:37:46,320
das heißt es ist auch besser 
testbar und wartbar ne wenn ich 

726
00:37:46,440 --> 00:37:49,440
n Test schreibe für den Windows 
Button und den Linux Button 

727
00:37:49,440 --> 00:37:51,680
änder, dann hab ich halt am 
Windows Button Test natürlich 

728
00:37:51,680 --> 00:37:53,880
auch immer noch grün, 
hoffentlich am Ende ne wenn ich 

729
00:37:53,880 --> 00:37:55,800
es richtig implementiert habe 
das heißt? 

730
00:37:55,880 --> 00:37:58,280
Wir haben halt keinen zentralen 
Code mehr, der alles wissen 

731
00:37:58,280 --> 00:38:03,200
muss, sondern wir lagern es auf 
die Subklassen aus, was laut 

732
00:38:03,200 --> 00:38:05,480
Objektorientiert einfach denn 
sauber getrennt ist. 

733
00:38:05,840 --> 00:38:12,120
Ja, definitiv. 
Und im Endeffekt. 

734
00:38:12,120 --> 00:38:14,160
Also es gibt natürlich auch 
Nachteile, es ist ja nicht immer

735
00:38:14,160 --> 00:38:16,320
nur so, dass es da die ganze 
Zeit immer nur ne Vorteil 

736
00:38:16,320 --> 00:38:20,480
Vorteil, Vorteil, du brauchst 
natürlich n komplexeres Setup 

737
00:38:20,480 --> 00:38:22,280
irgendwo ne, also du hast 
natürlich jetzt. 

738
00:38:23,880 --> 00:38:26,000
Also dein ganzer Code wird 
natürlich komplexer an dieser 

739
00:38:26,000 --> 00:38:28,560
Stelle, weil du zum Beispiel ne,
gerade wenn du sagst, du hast 

740
00:38:28,960 --> 00:38:33,280
mehrere Objekte von einer, also 
die, die zusammengehören zu 

741
00:38:33,280 --> 00:38:37,120
einer Familie, ne, dann brauchst
du halt so ne so ne basisklasse,

742
00:38:37,120 --> 00:38:40,480
die dir sagt, OK ne, meine 
ganzen Bürger sind am Ende n 

743
00:38:40,480 --> 00:38:43,360
Bürger ne die verschiedenen. 
Wenn du jetzt aber das ganze 

744
00:38:43,360 --> 00:38:46,640
noch länderspezifisch spezifisch
aufteilst, dann hast du 

745
00:38:46,640 --> 00:38:49,320
verschiedene. 
Burger, die zum Beispiel keine 

746
00:38:49,320 --> 00:38:51,000
Ahnung, amerikanische Burger 
sind. 

747
00:38:51,000 --> 00:38:54,040
Du hast Burger, die aber 
asiatische Burger sind, ne, und 

748
00:38:54,040 --> 00:38:57,600
dann hast du wieder diesen diese
beiden Burger Varianten, die 

749
00:38:57,600 --> 00:39:00,320
aber am Ende auch wieder nur 
Burger sind, das heißt du holst 

750
00:39:00,320 --> 00:39:03,280
dir natürlich ne höhere 
Komplexität, ne höhere Tiefe, ne

751
00:39:03,280 --> 00:39:07,080
in deinen Code rein. 
Und das kann natürlich auch dazu

752
00:39:07,080 --> 00:39:10,200
führen, dass es vielleicht n 
bisschen schwieriger am Anfang 

753
00:39:10,200 --> 00:39:11,120
durchzublicken ist. 
Ne. 

754
00:39:11,120 --> 00:39:14,200
Deswegen heißt das andere ja 
auch simple Factory, weil es 

755
00:39:14,200 --> 00:39:18,120
halt eigentlich eher n bisschen 
flacher Gehalt, also diese ganze

756
00:39:18,120 --> 00:39:19,280
Hierarchie n bisschen flacher 
hält. 

757
00:39:19,280 --> 00:39:22,720
Aber wie gesagt, hier macht es 
mehr Sinn, wenn es auch n 

758
00:39:22,720 --> 00:39:25,000
bisschen generell, wenn wenn 
diese ganze Abhängigkeit 

759
00:39:25,000 --> 00:39:28,160
komplexer wird, dann also ne mit
einer höheren Komplexität steigt

760
00:39:28,160 --> 00:39:29,920
meistens halt auch die 
Komplexität des Codes. 

761
00:39:30,960 --> 00:39:33,200
Ja, es ist natürlich ratsam, 
immer zu gucken. 

762
00:39:33,440 --> 00:39:36,160
Je höher also auch, wenn die 
Komplexität steigt, Krieg ich es

763
00:39:36,160 --> 00:39:39,280
vielleicht doch mit möglichst 
wenig Komplexität in meinem Code

764
00:39:39,280 --> 00:39:43,200
hin, aber ab einem ab einer 
gewissen Ebene kommt man halt 

765
00:39:43,200 --> 00:39:47,040
einfach nicht da dazu, dass man 
halt eine gewisse Komplexität 

766
00:39:47,040 --> 00:39:51,040
vermeiden kann. 
Ja, und das ist auch ein gutes 

767
00:39:51,040 --> 00:39:54,480
Stichwort, Komplexität, und das 
wäre so im Prinzip die dritte 

768
00:39:54,480 --> 00:39:57,320
Stufe. 
Von den Pattern ist dann die 

769
00:39:57,320 --> 00:40:02,800
sogenannte Abstract Factory, das
heißt, wir fangen jetzt quasi 

770
00:40:02,800 --> 00:40:06,520
noch an, uns zu überlegen. 
OK, ich hab ne Factory und ich 

771
00:40:06,520 --> 00:40:09,920
kann jetzt zum Beispiel 
länderspezifisch den Burger 

772
00:40:09,920 --> 00:40:13,400
Design ne, also beispielsweise 
ich möchte n cheeseburger haben 

773
00:40:13,400 --> 00:40:16,640
und der sieht halt wie gesagt in
Japan anders aus als in der USA.

774
00:40:16,640 --> 00:40:18,960
So das können wir jetzt schon 
ganz gut abbilden. 

775
00:40:19,560 --> 00:40:21,680
Wie sieht das jetzt aber zum 
Beispiel aus, wenn wir ganze 

776
00:40:21,680 --> 00:40:24,880
Produktfamilien haben und da 
kommt dann die Abstract Factory 

777
00:40:24,880 --> 00:40:27,040
ins Spiel, das heißt, wir haben 
Produktfamilien, die 

778
00:40:27,040 --> 00:40:30,200
Zusammengehörig sind, und das 
kann man an dem Beispiel, wir 

779
00:40:30,200 --> 00:40:33,520
sind wieder bei dem Burger auch 
wieder gut erklären, weil ich 

780
00:40:33,520 --> 00:40:36,480
hab jetzt nicht nur Bock n 
Burger zu essen, ich fühle es, 

781
00:40:36,480 --> 00:40:39,520
ich möchte n Menü haben, ja. 
Ja. 

782
00:40:40,000 --> 00:40:42,840
Und. 
Habe jetzt quasi Burger, eine 

783
00:40:42,840 --> 00:40:47,520
Beilage und ein Getränk. 
So und das alles natürlich so 

784
00:40:47,520 --> 00:40:50,520
wie ich es erwarte im Stil des 
Restaurants, wo ich gerade 

785
00:40:50,520 --> 00:40:57,120
bestelle, ja sagen wir mal zum 
Beispiel bei einem Cheeseburger 

786
00:40:57,120 --> 00:41:01,760
in Amerika kriege ich halt so 
klassisch Doktor Pepper Cola 

787
00:41:01,760 --> 00:41:07,600
keine Ahnung und Fries und in 
Japan zu meinem Teriyaki Burger 

788
00:41:07,600 --> 00:41:09,840
will ich jetzt nicht unbedingt 
eine Doktor Pepper dazu haben, 

789
00:41:09,840 --> 00:41:12,800
sondern ich kriege. 
Ah, Klischee, auf keiner Matcha 

790
00:41:12,800 --> 00:41:14,960
Tee oder so. 
Weißt du also was ich damit 

791
00:41:14,960 --> 00:41:20,000
meine ist, du hast ja im Prinzip
die Menüs die angeboten werden 

792
00:41:20,000 --> 00:41:23,200
von dem Restaurant sind 
natürlich auch spezifisch und im

793
00:41:23,200 --> 00:41:27,600
Stile ihres Restaurants ja also.
Da, das wird sich ja denn 

794
00:41:27,600 --> 00:41:31,520
grundlegend als gesamte 
Produktfamilie Burger Menü 

795
00:41:31,680 --> 00:41:35,480
unterscheiden und da kommt halt 
denn die Factory ins Spiel, die 

796
00:41:35,520 --> 00:41:39,520
Abstract Factory, die dann 
wiederum deine Factory so 

797
00:41:39,520 --> 00:41:42,400
definiert, zum Beispiel, dass du
sagst, ich bin in Japan oder in 

798
00:41:42,400 --> 00:41:48,520
der USA und dafür sorgt, dass 
die einzelne Produkte, die jetzt

799
00:41:48,520 --> 00:41:52,360
ne Factory intern bereitstellen 
kann sowas wie gib mir einen 

800
00:41:52,360 --> 00:41:54,640
Burger, gib mir eine Beilage, 
gib mir ein Getränk. 

801
00:41:55,600 --> 00:41:59,440
Dafür sorgt, dass es in sich zur
gleichen Produktfamilie gehört, 

802
00:41:59,520 --> 00:42:02,160
dass ich halt nicht sage, ich 
Krieg n amerikanischen Burger 

803
00:42:02,160 --> 00:42:05,360
und ne japanische Beilage zum 
Beispiel, das wär auch Wahnsinn,

804
00:42:06,360 --> 00:42:09,040
das wär Wahnsinn, das nennt man 
Fusionsküche. 

805
00:42:09,760 --> 00:42:13,120
Fusionsküche genau, aber weißt 
du, wie ich meine? 

806
00:42:13,120 --> 00:42:14,880
Und ich finde, da kann man das 
eigentlich ganz gut dran 

807
00:42:14,880 --> 00:42:17,480
erkennen, denn oder 
beziehungsweise verstehen, warum

808
00:42:17,480 --> 00:42:19,640
man diesen Schritt auch noch. 
Geht ja. 

809
00:42:19,640 --> 00:42:21,760
Wenn wir jetzt zum Beispiel noch
mal dieses UI Beispiel von 

810
00:42:21,760 --> 00:42:24,800
vorhin nehmen, ne und das noch 
zum Beispiel auch noch mal daran

811
00:42:24,800 --> 00:42:28,160
erklären, noch mal in die 
Technik n bisschen so 

812
00:42:28,880 --> 00:42:32,360
abzutauchen ein wenig, dann ist 
es ja so, dass du zum Beispiel 

813
00:42:32,360 --> 00:42:36,720
sagst, ich möchte jetzt ein, 
also meine UI Elemente haben, 

814
00:42:36,720 --> 00:42:38,360
ne. 
Also nicht nur einen Button, 

815
00:42:38,360 --> 00:42:40,640
sondern ich möchte vielleicht 
auch noch eine Checkbox haben 

816
00:42:40,640 --> 00:42:44,440
oder ich möchte was gibt es noch
einen Radio Button haben oder 

817
00:42:44,440 --> 00:42:47,840
was auch immer, so verschiedene 
Elemente, die aber auch wieder 

818
00:42:47,840 --> 00:42:49,920
logischerweise entsprechend 
gestylt sind. 

819
00:42:49,920 --> 00:42:55,360
Du kriegst ja nicht einen Mac 
Button in Windows Checkbox und 

820
00:42:55,360 --> 00:42:59,000
eine Linux Radio Button, das 
wird ja im Endeffekt, also 

821
00:42:59,000 --> 00:43:00,960
kannst du auch machen, wäre aber
irgendwie blöd. 

822
00:43:01,760 --> 00:43:04,560
So, und dann ist es halt im 
Endeffekt so, dass du halt 

823
00:43:04,720 --> 00:43:08,160
abhängig vom Betriebssystem dir 
diese Familie holst. 

824
00:43:08,160 --> 00:43:13,040
Von Ui Elementen, von denen du 
dann wiederum ein spezifisches 

825
00:43:13,040 --> 00:43:15,040
brauchst. 
Und im Endeffekt kann man sich 

826
00:43:15,040 --> 00:43:18,960
das so vorstellen, dass Du eine 
Factory hast, die anhand des 

827
00:43:20,400 --> 00:43:23,800
Betriebssystems und also 
unterscheidet, wenn. 

828
00:43:23,920 --> 00:43:27,760
Welche Factory sie dir gibt, um 
den entsprechenden Einzelnen, 

829
00:43:27,840 --> 00:43:29,520
das einzelne Ui Element zu 
bekommen. 

830
00:43:29,520 --> 00:43:31,840
Das heißt du hast eine Factory 
die dir eine Factory ausspuckt, 

831
00:43:31,920 --> 00:43:33,760
die dir dann am Ende wieder ein 
Objekt gibt. 

832
00:43:35,280 --> 00:43:39,640
Genau also im Prinzip. 
Das ist ein gutes Beispiel, und 

833
00:43:39,640 --> 00:43:42,960
wenn wir jetzt noch mal so auf 
auf die Ui Elemente gehen, du 

834
00:43:42,960 --> 00:43:46,240
definierst ja nicht jedes Mal. 
Also du, du erzeugst dir jetzt 

835
00:43:46,240 --> 00:43:48,680
ja nicht eine Factory für 
Buttons und sagst jedes Mal wenn

836
00:43:48,680 --> 00:43:51,280
Du einen Button haben möchtest 
übrigens Windows. 

837
00:43:51,760 --> 00:43:53,200
Und jetzt gib mir noch ne 
Checkbox. 

838
00:43:53,280 --> 00:43:56,720
Übrigens Windows ja und dann 
machst du irgendwann den Fehler.

839
00:43:56,720 --> 00:43:59,560
Übrigens Linux. 
Ach verdammt weißt du und 

840
00:43:59,560 --> 00:44:03,960
deswegen gehst du quasi diesen 
Weg mit der Abstract Factory und

841
00:44:03,960 --> 00:44:08,720
sagst gib mir ne UI Factory 
Windows und die kann dir jetzt 

842
00:44:08,720 --> 00:44:12,960
sagen create Button, create 
checkbox und es wird immer. 

843
00:44:13,400 --> 00:44:16,840
Windows sein am Ende, weil du 
das unter der Haube quasi so 

844
00:44:16,840 --> 00:44:18,800
definiert hast. 
Und dann musst du dir bei der 

845
00:44:18,800 --> 00:44:21,520
Anwendung oder bei dem Erstellen
der Objekte darüber keine 

846
00:44:21,520 --> 00:44:24,760
Gedanken mehr machen und das 
bringt halt mehrere Vorteile mit

847
00:44:24,760 --> 00:44:26,640
sich. 
Also erstmal, es ist konsistent,

848
00:44:26,640 --> 00:44:29,040
ja wie du gerade meintest, es 
passt alles zusammen, 

849
00:44:29,040 --> 00:44:31,680
beispielsweise wenn ich 
betriebssystemabhängig bin. 

850
00:44:32,200 --> 00:44:34,480
Es ist super testbar. 
Ich kann die einzelnen 

851
00:44:34,480 --> 00:44:38,880
Betriebssystem Stylings abtesten
es ist austauschbar, ne, weil es

852
00:44:38,880 --> 00:44:41,760
muss ja nicht nur Betriebssystem
abhängig sein, so ein 

853
00:44:41,760 --> 00:44:46,080
klassischer Anwendungsfall sind 
ja auch so Themes sage ich mal 

854
00:44:46,080 --> 00:44:49,040
ne habe ich ein helles Layout, 
habe ich ein dunkles Layout und 

855
00:44:49,040 --> 00:44:51,880
ich möchte ja nicht bei jedem UI
Element sagen, übrigens du bist 

856
00:44:51,880 --> 00:44:55,080
gerade ein dunkles Layout oder 
ein helles Layout nein du willst

857
00:44:55,080 --> 00:44:57,920
es ja global irgendwo 
entscheiden und dann einfach 

858
00:44:57,920 --> 00:45:01,520
darauf arbeiten sozusagen oder 
wenn du eine Testumgebung 

859
00:45:01,520 --> 00:45:04,080
erzeugen willst dann. 
Willst du ja auch sagen, gib mir

860
00:45:04,080 --> 00:45:07,320
mal meine Test Factory, ich will
jetzt da was ausprobieren, zum 

861
00:45:07,320 --> 00:45:10,800
Beispiel also das das bringt 
halt viele Vorteile mit sich 

862
00:45:10,800 --> 00:45:13,040
schnell austauschbar auch zu 
sein. 

863
00:45:13,680 --> 00:45:16,960
Ja Nachteil glaube ich kann man 
eigentlich ganz schnell erklären

864
00:45:16,960 --> 00:45:20,480
oder komplex. 
Ja klar, das ist natürlich die 

865
00:45:21,040 --> 00:45:23,440
komplexeste Variante von allen 
Factories. 

866
00:45:23,760 --> 00:45:27,400
Und wie gesagt, ich ich 
persönlich würde auch darauf 

867
00:45:27,400 --> 00:45:30,160
verzichten, wenn es nicht 
notwendig wäre, ne, also diese 

868
00:45:30,160 --> 00:45:34,600
dritte Variante. 
Was ich noch sagen würde ist, 

869
00:45:34,600 --> 00:45:37,320
weil das ist zum Beispiel auch n
Punkt, der hat sich früher 

870
00:45:37,320 --> 00:45:39,400
irgendwie ganz am Anfang von 
meinem Studium. 

871
00:45:39,400 --> 00:45:42,400
Zum Beispiel hat sich auch nicht
so richtig erschlossen und ich 

872
00:45:42,400 --> 00:45:45,280
würd das auch vielleicht noch 
mal so, weil ich denk mir so, 

873
00:45:45,280 --> 00:45:47,200
vielleicht hat man mal das 
Problem gehabt, was vielleicht 

874
00:45:47,200 --> 00:45:50,080
andere auch haben oder das 
Verständnisproblem, man kann 

875
00:45:50,080 --> 00:45:52,120
sich ja jetzt hinstellen und 
sagen, was bringt denn 

876
00:45:52,120 --> 00:45:54,440
eigentlich so ne Factory, wieso 
sag ich jetzt zum Beispiel nicht

877
00:45:54,440 --> 00:45:56,600
einfach ey, dann erstelle ich 
mir n neues Objekt davon und 

878
00:45:56,600 --> 00:45:59,640
dann mach ich damit was und da 
an einer anderen Stelle nehm ich

879
00:45:59,640 --> 00:46:02,640
mir halt n anderes Objekt. 
Ne was ich da halt vielleicht 

880
00:46:02,640 --> 00:46:05,360
brauche und dann mache ich das 
halt ne, weil du ja meintest am 

881
00:46:05,360 --> 00:46:08,040
Anfang um noch mal den Bogen zum
Anfang zu schießen. 

882
00:46:08,040 --> 00:46:11,040
Du hast dann überall mal New 
Objekt von dem New Objekt von 

883
00:46:11,040 --> 00:46:14,080
dem mach mal dies mach mal das 
ne und wenn du dir jetzt zum 

884
00:46:14,080 --> 00:46:18,000
Beispiel vorstellst du hast n ne
Anwendung auf deinem eigenen 

885
00:46:18,000 --> 00:46:20,960
Server laufen und du sagst zum 
Beispiel OK ich möchte aber 

886
00:46:20,960 --> 00:46:25,120
diesen Server, also ich möchte 
meine Anwendung überwachen und 

887
00:46:25,120 --> 00:46:27,600
du hast jetzt zum Beispiel du 
fängst an und sagst OK ich 

888
00:46:27,600 --> 00:46:30,800
möchte jetzt. 
Diese, wenn irgendein Problem 

889
00:46:30,800 --> 00:46:32,800
auftritt, möchte ich zum 
Beispiel mich selber 

890
00:46:32,800 --> 00:46:38,200
notifizieren, ne mit einer e 
Mail so dann mach ich, erstelle 

891
00:46:38,200 --> 00:46:42,320
ich irgendwie mir so NE Mail 
notifier und sag send mal die 

892
00:46:42,320 --> 00:46:46,040
notification raus über die e 
Mail ne so und dann hast du aber

893
00:46:46,040 --> 00:46:48,400
vielleicht irgendwann denkst du 
dir so oh e Mail wirklich, das 

894
00:46:48,400 --> 00:46:51,500
ist einfach da ich ich guck 
nicht immer so oft in die e 

895
00:46:51,500 --> 00:46:54,640
Mails ich brauch das vielleicht 
als SMS oder so ne so das heißt 

896
00:46:54,640 --> 00:46:56,320
du sagst ey ich erstell mir 
jetzt noch n. 

897
00:46:56,760 --> 00:46:59,480
Weiteren Notifire, nämlich einen
SMS notifire und sende dann 

898
00:46:59,480 --> 00:47:02,560
sozusagen noch als SMS raus. 
So, und wenn du jetzt aber 

899
00:47:02,560 --> 00:47:05,320
irgendwann sagst, weiß nicht 
SMS, ich habe manchmal irgendwie

900
00:47:05,320 --> 00:47:07,400
bin in einem Funkloch, aber 
Internet habe ich irgendwie, ich

901
00:47:07,400 --> 00:47:09,920
brauche das auch noch für eine 
App als push Nachricht, dann 

902
00:47:09,920 --> 00:47:12,560
machst du noch einen Push 
notifire so ne, dann hast du 3 

903
00:47:12,560 --> 00:47:16,320
verschiedene Notifire, die du 
aber alle in diesem wenn jetzt 

904
00:47:16,320 --> 00:47:18,960
zum Beispiel ein Fehler in 
deinem in deiner Anwendung 

905
00:47:18,960 --> 00:47:21,840
auftritt, möchtest du über alle 
notifire dich notifizieren, 

906
00:47:21,840 --> 00:47:23,120
damit du auch wirklich 
mitkriegst. 

907
00:47:23,120 --> 00:47:25,840
Es ist ein Fehler aufgetreten im
System ne. 

908
00:47:26,640 --> 00:47:28,840
Und egal, wo du dich gerade 
aufhältst, entweder du hast kein

909
00:47:28,840 --> 00:47:31,560
Internet oder du hast einen 
Netzausfall oder du hast gerade 

910
00:47:31,560 --> 00:47:34,640
keine Ahnung, mal wieder nicht 
in die e Mails geguckt, irgendwo

911
00:47:34,640 --> 00:47:37,640
willst du es halt herkriegen 
diese Information und dann 

912
00:47:37,640 --> 00:47:40,880
möchtest du deinem Code aber 
nicht sagen, create new e mail 

913
00:47:40,880 --> 00:47:46,000
notifeier und sende create new 
SMS notifeier und sende create 

914
00:47:46,000 --> 00:47:49,600
new push notifeier und sende ne,
das müsstest du ja für jeden, 

915
00:47:49,600 --> 00:47:51,920
für jedes immer wieder noch mal 
neu machen. 

916
00:47:52,440 --> 00:47:55,040
Und wenn du jetzt aber sagst, 
ein e Mail notifier und eine SMS

917
00:47:55,040 --> 00:47:58,080
Notifier und Push notifier sind 
alles irgendwo notifier ist 

918
00:47:58,080 --> 00:48:00,200
jetzt egal welche Factory an der
Stelle und wie das genau 

919
00:48:00,200 --> 00:48:03,520
implementiert ist. 
Aber du kannst dann zum Beispiel

920
00:48:03,520 --> 00:48:06,000
wenn du noch ein Notifier 
hinzufügen möchtest, kannst du 

921
00:48:06,000 --> 00:48:10,000
alle in eine Liste von Notifier 
packen und dann mit einer vor 

922
00:48:10,000 --> 00:48:14,200
darüber gehen und einfach sagen 
okay notifier send so, das heißt

923
00:48:14,200 --> 00:48:18,080
du hast einen viel eleganteren 
Code am Ende als immer zu sagen.

924
00:48:18,600 --> 00:48:21,680
Also du musst natürlich diesen 
Notifire dann über deine Factory

925
00:48:21,680 --> 00:48:24,720
die entsprechenden Notifire 
erstellen und einen neuen 

926
00:48:24,720 --> 00:48:26,240
hinzufügen. 
Du musst aber nicht jedes Mal 

927
00:48:26,240 --> 00:48:29,520
sagen okay, ich mache das jetzt 
für jedes erstelle ich ein neues

928
00:48:29,520 --> 00:48:31,600
Objekt und so weiter und sofort,
sondern du nutzt immer nur die 

929
00:48:31,600 --> 00:48:34,800
Factory sagst du möchtest ein 
bestimmtes neues Ding haben, 

930
00:48:35,440 --> 00:48:38,440
kriegst es dann packst es in die
Liste und wenn du jetzt zum 

931
00:48:38,440 --> 00:48:40,960
Beispiel sagst, du hast eine 
Liste und in vielen Sprachen die

932
00:48:40,960 --> 00:48:43,360
jetzt auch Typsicher sind, 
kannst du ja nicht sagen, ich 

933
00:48:43,360 --> 00:48:45,360
erstell eine Liste von einem 
Objekt. 

934
00:48:45,680 --> 00:48:49,280
E Mail notifire von dem Objekt 
SMS Notifire und von dem Objekt 

935
00:48:49,280 --> 00:48:51,440
Push notifire weil es sind 3 
unterschiedliche Objekte. 

936
00:48:51,440 --> 00:48:54,400
Wenn du aber sagst das sind 
alles notifire, dann kannst du 

937
00:48:54,640 --> 00:48:56,960
ne Liste von Notifirern 
erstellen und dann darüber 

938
00:48:56,960 --> 00:49:01,600
iterieren und das sind manchmal 
so dann die Vorteile die das 

939
00:49:01,600 --> 00:49:04,520
dann am Ende mit sich bringt. 
So weißt du so Kleinigkeiten wo 

940
00:49:04,520 --> 00:49:08,200
ich am Anfang wo ich mir weißt 
du das ist immer so bescheuert 

941
00:49:08,200 --> 00:49:10,560
so am Anfang des Studiums dachte
ich dann so was wie ja was 

942
00:49:10,560 --> 00:49:13,120
brauche ich das ich verstehe den
Anwendungsfall noch nicht und 

943
00:49:13,120 --> 00:49:15,960
irgendwann kam ich an den Punkt 
wo ich mir dachte das ich würd 

944
00:49:15,960 --> 00:49:18,280
das jetzt gern alles in eine 
Liste packen aber es geht nicht 

945
00:49:18,400 --> 00:49:22,480
und dann irgendwann kam so diese
Connection wo ich mir dachte Oh 

946
00:49:22,480 --> 00:49:27,560
ne Factory weißt du und das kann
man halt wie gesagt ist 

947
00:49:27,560 --> 00:49:31,480
unabhängig vom Typ der Factory 
kann man mit allen machen, die 

948
00:49:31,480 --> 00:49:34,320
Implementierung ist dann sei mal
dahingestellt, da haben wir ja 

949
00:49:34,400 --> 00:49:36,080
auch schon n paar Beispiele 
genannt, aber das ist zum 

950
00:49:36,080 --> 00:49:40,240
Beispiel finde ich n sehr sehr 
wichtiges Beispiel um zu zeigen 

951
00:49:40,400 --> 00:49:44,080
so kannst du ne Factory nutzen 
als genau. 

952
00:49:44,080 --> 00:49:48,240
Es hält halt den Code schlank, 
dann am Ende alright. 

953
00:49:48,640 --> 00:49:51,160
Genau dann hatten wir ja noch n 
konkretes Beispiel am Ende dann 

954
00:49:51,240 --> 00:49:52,880
würde ich sagen lass uns doch 
mal noch mal kurz 

955
00:49:52,880 --> 00:49:57,280
zusammenfassen, ich kann ja noch
mal die meta Analogie Ebene 

956
00:49:57,280 --> 00:50:03,040
zusammenfassen, die wir so quasi
aufgebaut haben in dieser Folge 

957
00:50:03,360 --> 00:50:06,560
also gehen wir noch mal quasi 
von. 

958
00:50:08,920 --> 00:50:12,120
Unserem Burgerladen aus ne also 
die simple Factory ist ich geh 

959
00:50:12,120 --> 00:50:14,000
jetzt hin und bestelle einen 
einzelnen Burger. 

960
00:50:14,000 --> 00:50:17,520
Ja, also wirklich nur ich bin in
einem Laden, es gibt nur diesen 

961
00:50:17,520 --> 00:50:20,160
Laden, es gibt nur einen 
definierten Cheeseburger und ich

962
00:50:20,160 --> 00:50:22,080
will n Cheeseburger haben, dann 
ist klar wie der aussieht und 

963
00:50:22,080 --> 00:50:27,280
ich Krieg den ja das erweitert 
wenn wir jetzt gesagt haben na 

964
00:50:27,280 --> 00:50:30,680
ja verschiedene Köche gleiche 
Karte aber unterschiedlicher 

965
00:50:30,680 --> 00:50:33,440
Burger ne also ich kann jetzt 
bei verschiedenen Köchen. 

966
00:50:33,800 --> 00:50:35,880
Einen Cheeseburger bestellen und
der wird halt unterschiedlich 

967
00:50:35,880 --> 00:50:39,200
sein am Ende, weil es ja der 
unter unterschiedlich zubereitet

968
00:50:39,200 --> 00:50:40,520
wird, sehr wahrscheinlich, da 
hatten wir ja die 

969
00:50:40,520 --> 00:50:43,600
Länderbeispiele genannt und da 
kommt halt die Factory, das 

970
00:50:43,600 --> 00:50:45,920
eigentliche Factory Pattern ins 
Spiel, dass man sagt, gut, wir 

971
00:50:45,920 --> 00:50:49,440
haben jetzt abstrakten Burger 
und der wird jetzt in den 

972
00:50:49,440 --> 00:50:53,080
Subklassen definiert 
Cheeseburger und so sieht er aus

973
00:50:53,080 --> 00:50:55,800
und jeder implementiert sich 
seinen Cheeseburger, sozusagen 

974
00:50:55,800 --> 00:50:58,720
ne und dann abhängig davon wo 
ich bin, kriege ich dann 

975
00:50:58,720 --> 00:51:02,400
dementsprechend den Cheeseburger
und die Abstract Factory. 

976
00:51:03,520 --> 00:51:06,640
Die maximale Ausbaustufe, sag 
ich mal, ist halt das 

977
00:51:06,640 --> 00:51:09,120
Menübeispiel. 
Wenn ich jetzt n komplettes Menü

978
00:51:09,120 --> 00:51:11,280
haben möchte, dann krieg ich 
halt auch entsprechend immer 

979
00:51:11,280 --> 00:51:14,320
passend Beilagen und Getränke 
beziehungsweise ich kann denn 

980
00:51:14,320 --> 00:51:17,600
nur auswählen, was passend für 
den Laden dazu ist. 

981
00:51:17,600 --> 00:51:19,760
Ja, also wie sieht das Burger 
Menü da aus? 

982
00:51:20,320 --> 00:51:22,120
Genau. 
Und das ganze n bisschen 

983
00:51:22,120 --> 00:51:23,840
technisch. 
Kannst du es noch so n bisschen 

984
00:51:23,840 --> 00:51:27,520
einordnen wo du was so ungefähr 
verwenden würdest? 

985
00:51:27,520 --> 00:51:29,000
Zum Beispiel? 
Wir hatten es ja jetzt auch so 

986
00:51:29,000 --> 00:51:30,480
in der Folge n bisschen 
angeschnitten. 

987
00:51:30,640 --> 00:51:35,120
Ja, also simple Factory, ne, da 
hat man hat man eher zum 

988
00:51:35,120 --> 00:51:38,280
Beispiel so n Interface was man 
verwendet für kleinere Projekte 

989
00:51:38,280 --> 00:51:41,120
vielleicht Tutorials ne wenn man
jetzt nicht so viele Varianten 

990
00:51:41,120 --> 00:51:45,040
von Objekten von von von einem 
Typ hat, beispielsweise das 

991
00:51:45,040 --> 00:51:47,200
Factory Pattern jetzt 
beispielsweise. 

992
00:51:48,280 --> 00:51:51,760
Wenn man dann mehr Objekte, wenn
es komplexer wird, man halt 

993
00:51:51,760 --> 00:51:55,880
mehrere Objekte hat, die 
vielleicht auch noch in Klassen 

994
00:51:55,880 --> 00:52:00,280
wiederum gegliedert werden 
können, ne und also wie jetzt 

995
00:52:00,280 --> 00:52:02,760
zum Beispiel halt ne, was du ja 
auch gerade beschrieben hattest 

996
00:52:02,760 --> 00:52:08,120
mit deinen Beispielen und wenn 
du jetzt abstract Factory ne 

997
00:52:08,120 --> 00:52:11,120
Abstract factory nimmst, dann 
bist du halt auf 

998
00:52:11,520 --> 00:52:16,160
unterschiedlichen Objektfamilien
unterwegs. 

999
00:52:16,640 --> 00:52:19,840
Dass du halt sagst, okay. 
Du kannst erstmal über das 

1000
00:52:19,840 --> 00:52:24,880
Factory Pattern kannst du dir 
ein eine bestimmte Familie 

1001
00:52:24,880 --> 00:52:28,880
überhaupt holen, dass man da gar
nicht irgendwie sich vertun kann

1002
00:52:28,880 --> 00:52:32,080
und dann ein spezifisches Objekt
aus dieser Familie, das heißt du

1003
00:52:32,160 --> 00:52:40,560
Filterst im Endeffekt ein 
bisschen vor, so und ja, dafür 

1004
00:52:40,560 --> 00:52:43,360
sind eigentlich die Sachen ganz 
gut gedacht, wie gesagt, es ist 

1005
00:52:43,600 --> 00:52:45,920
ich glaube so ein Abstract 
Factory. 

1006
00:52:47,040 --> 00:52:49,440
Habe ich zum Beispiel selber 
noch gar nicht verwenden müssen,

1007
00:52:49,760 --> 00:52:53,920
weil es ist auch immer die 
Frage, wann braucht man das 

1008
00:52:53,920 --> 00:52:56,080
wirklich. 
Es ist, es ist ratsam, so was 

1009
00:52:56,080 --> 00:52:58,800
irgendwann mal einfach 
spaßeshalber zu programmieren, 

1010
00:52:59,440 --> 00:53:02,600
um es mal gemacht zu haben, aber
das bedeutet noch lange nicht, 

1011
00:53:02,600 --> 00:53:05,320
dass es unbedingt wichtig ist, 
das anzuwenden, ne, aber wenn du

1012
00:53:05,320 --> 00:53:08,400
jetzt zum Beispiel sagst simple 
Factory und Factory Pattern, 

1013
00:53:08,480 --> 00:53:11,760
diese beiden würde ich zum 
Beispiel schon als sehr 

1014
00:53:11,760 --> 00:53:14,960
hochfrequent einordnen und das 
ist durchaus wirklich wichtig, 

1015
00:53:14,960 --> 00:53:17,120
dass man auch dann. 
Das versteht und das auch 

1016
00:53:17,120 --> 00:53:19,840
anwenden. 
Kann also. 

1017
00:53:19,920 --> 00:53:23,360
Die Abstract Factory ist sehr 
wahrscheinlich oder oftmals 

1018
00:53:23,360 --> 00:53:25,680
nicht notwendig selbst zu 
implementieren, weil man ja auch

1019
00:53:25,680 --> 00:53:29,680
oft auf Frameworks und Libraries
zurückgreift, die das unter der 

1020
00:53:29,680 --> 00:53:31,880
Haube implementieren. 
Gerade so in der Cross Plattform

1021
00:53:31,880 --> 00:53:37,080
Welt wird das ja dir quasi genau
diese Sachen werden die ja 

1022
00:53:37,080 --> 00:53:40,080
abgenommen dann am Ende ne, weil
das halt unter der Haube so 

1023
00:53:40,080 --> 00:53:43,440
implementiert wurde. 
Aber das wäre auch so. 

1024
00:53:43,600 --> 00:53:46,400
Ich würde gerne noch so ein 2 
Tipps oder jeder ein Tipp kann 

1025
00:53:46,400 --> 00:53:48,960
man am Ende noch mitgeben so 
bevor ich die Folge schließe 

1026
00:53:48,960 --> 00:53:51,280
sage ich mal, das wäre nämlich 
auch genau mein Tipp gewesen, 

1027
00:53:51,280 --> 00:53:54,240
was du gerade angeschnitten 
hast. 

1028
00:53:54,240 --> 00:53:56,840
Ist liebe Zuhörer, liebe 
Zuhörer, falls du dich mit dem 

1029
00:53:56,840 --> 00:53:59,440
Factory Pattern noch nicht so 
auseinandergesetzt hast oder 

1030
00:53:59,440 --> 00:54:00,960
immer noch ein bisschen 
struggles, weil du vielleicht 

1031
00:54:00,960 --> 00:54:02,960
gerade am Anfang der 
Softwareentwicklung stehst, 

1032
00:54:03,840 --> 00:54:06,960
probiere es aus, nimm dir die 
Beispiele unserer Analogien wie 

1033
00:54:06,960 --> 00:54:10,000
zum Beispiel mcdonalds oder dem 
Burgerladen allgemein oder die 

1034
00:54:10,000 --> 00:54:13,280
Pizzeria oder. 
Und Programmier damit mal 

1035
00:54:13,280 --> 00:54:16,240
einfach n factory pattern, sag 
dir, ich mach jetzt n simple 

1036
00:54:16,240 --> 00:54:20,520
Factory, dann refactor ich das 
zum Factory Pattern zum Beispiel

1037
00:54:20,520 --> 00:54:23,040
und ich probier auch mal ruhig n
Abstract Factory aus, damit ich 

1038
00:54:23,040 --> 00:54:25,880
es einfach mal gemacht hab, dann
sieht man einfach, welche coole 

1039
00:54:25,880 --> 00:54:29,720
Möglichkeit dieses Pattern 
bildet oder bietet um Code zu 

1040
00:54:29,720 --> 00:54:32,000
strukturieren. 
Ja, auf jeden Fall. 

1041
00:54:32,320 --> 00:54:36,080
Und wie gesagt, am besten immer.
Kleinen anfangen, sich dann wie 

1042
00:54:36,080 --> 00:54:38,480
du auch eigentlich meintest ne 
du hangelt, man hangelt sich 

1043
00:54:38,480 --> 00:54:41,200
einfach von der einen Factory 
zur anderen durch und ich würde 

1044
00:54:41,200 --> 00:54:44,360
auch einfach mal wirklich sagen 
OK wenn man das gemacht hat und 

1045
00:54:44,360 --> 00:54:48,480
diese Factory gebaut hat würde 
ich noch mal sozusagen daneben 

1046
00:54:48,480 --> 00:54:50,240
legen. 
Das gleiche Beispiel was du 

1047
00:54:50,240 --> 00:54:53,120
gebaut hast und keine Factory 
verwenden um einfach mal genau 

1048
00:54:53,280 --> 00:54:56,160
gegenüber zu diesen diese 
Gegenüberstellung zu haben. 

1049
00:54:56,560 --> 00:54:59,280
Wie sieht es denn mit aus und 
wie sieht es ohne aus und was 

1050
00:54:59,280 --> 00:55:02,000
gefällt mir besser und die 
Antwort liegt nach dieser Folge 

1051
00:55:02,000 --> 00:55:03,840
eigentlich auf der Hand. 
Ja. 

1052
00:55:04,720 --> 00:55:06,680
Sehr gut. 
Ich denke, wir haben es sehr 

1053
00:55:06,680 --> 00:55:09,600
umfangreich besprochen, da sieht
man mal, dass man zu so einem 

1054
00:55:09,600 --> 00:55:12,840
Designpattern echt viel erzählen
kann, gerade wenn man damit mal 

1055
00:55:12,840 --> 00:55:16,000
so n bisschen Analogien bringt. 
Aber ganz ehrlich, das hilft 

1056
00:55:16,000 --> 00:55:18,600
einfach mega das zu verstehen, 
das hat mir damals geholfen und 

1057
00:55:18,600 --> 00:55:21,520
ich hätte mir gewünscht, dass 
mir jemand das mal so anhand von

1058
00:55:21,520 --> 00:55:25,520
einfachen Beispielen erklärt und
deswegen vielen Dank dafür, Fabi

1059
00:55:25,760 --> 00:55:29,760
ebenso Liebe zur Liebe zur falls
dir die Folge gefallen hat oder 

1060
00:55:29,760 --> 00:55:33,760
du Anmerkungen hast zu den 
Pattern oder Fragen, schreib uns

1061
00:55:33,760 --> 00:55:35,960
gerne. 
Alle Links zu den Plattformen 

1062
00:55:35,960 --> 00:55:38,320
oder auch unsere Podcast Mail 
findest du in den Shownotes. 

1063
00:55:38,720 --> 00:55:41,760
Wenn dir der Podcast allgemein 
gefällt, lass auch gerne ne 

1064
00:55:41,760 --> 00:55:45,520
Bewertung da, das hilft uns 
quasi weiter zu wachsen und noch

1065
00:55:45,520 --> 00:55:48,760
mehr Leuten unseren Content 
anbieten zu können und damit 

1066
00:55:48,760 --> 00:55:50,720
noch mehr Leute davon 
profitieren können. 

1067
00:55:50,880 --> 00:55:54,640
Und ja, ansonsten würde ich 
sagen, hören wir uns alle beim 

1068
00:55:54,640 --> 00:55:56,600
nächsten Mal wieder. 
Und lasst euch den Burger 

1069
00:55:56,600 --> 00:55:58,640
schmecken. 
Und lasst euch den Burger, ich 

1070
00:55:58,640 --> 00:56:02,560
geh jetzt Burger bestellen. 
Und habt ne gute Zeit bis dahin 

1071
00:56:02,560 --> 00:56:05,680
und bis zum nächsten Mal deine 
Coding Bodys. 

1072
00:56:05,840 --> 00:56:06,680
Gemeinsam besser.
