Latest / Coding Buddies | Tech & Dev-Mindset / #120 Design Patterns 2 - Code aus der Fabrik

Transcript

#120 Design Patterns 2 - Code aus der Fabrik · Coding Buddies | Tech & Dev-Mindset

0:00
Dieses Interface wurde für den Cheeseburger implementiert, das
0:03
heißt Brötchen, keine Ahnung, Patty, was kommt, da kommt da
0:07
überhaupt noch ne Gurke drauf, keine Ahnung was war da glaub
0:10
ich noch nie drauf. Ne.
0:11
Coding Buddies Dein Podcast rund um Softwareentwicklung und
0:15
aktueller Tech News herzlich Willkommen.
0:29
Einen wunderschönen guten Tag und herzlich Willkommen zur
0:33
neuen Folge vom Coding Buddies Podcast und Tino begrüße ich
0:38
hier ganz herzlich und ich hoffe, Tino, Du hast auch einen
0:41
so wunderschönen Tag, wie ich ihn gerade allen hier gewünscht.
0:43
Habe ja Moin Moin fabi, ja ich habe einen super Tag, es ist
0:49
tolles Wetter, ich genieße das so richtig drin zu sein und.
0:54
Um mit dir jetzt n Podcast aufzunehmen.
0:56
Ich hab Bock, ich hab Bock. Das ist sehr gut, das freut
0:58
mich. Wir haben nämlich auch heute
1:00
wieder n sehr interessantes Thema.
1:02
Also ich freu mich auf die Folge, ich hab da echt Bock
1:04
drauf, hab ich ja sonst auch immer, aber irgendwie weißt du
1:07
es gibt immer mal so da da da stehst du morgens auf und denkst
1:11
dir heute n Podcast aufnehmen. Fühl ich so mit dem Thema.
1:17
Ja, ich find es auch. Was haben wir denn so?
1:18
Wir haben ja n ganz cooles Thema heute und zwar wollen wir so
1:22
richtig durchstarten mit unserer neuen Reihe zum Thema Design
1:26
Pattern und quasi heute mal so das erste Pattern besprechen.
1:31
Doch bevor wir sagen, welches das ist und so richtig
1:34
reinstarten noch ganz kurz die Anmerkung, Liebe Zuhörer, liebe
1:37
Zuhörer, falls dir dieser Podcast gefällt, du den
1:40
Abfeierst, ihn vielleicht schon länger hörst, so Mehrwert
1:42
rausziehen kannst, schau doch mal in die Shownotes, da gibt es
1:45
einen kleinen Spendenlink. Falls du Bock hast zu uns zu
1:47
unterstützen, wir würden uns mega darüber freuen.
1:50
Das nur kurz als Anmerkung. Werbung ändern an dem Punkt.
1:53
Und deswegen fabi, Hau doch mal raus, was für ein Pattern kommt
1:58
heute, wir haben es ja in der Einleitungsfolge schon mal etwas
2:02
angeteasert und genau das haben wir auch jetzt gemacht.
2:05
Wir haben gesagt, wir nehmen einfach ein Pattern, was ich
2:07
glaube einfach wirklich, wirklich, wirklich oft einem
2:10
über den Weg läuft und zwar das Factory Pattern und ich finde
2:14
auch persönlich ist es auch ein. Pattern, was ich auch häufig
2:19
sehe, häufig nutze also auch selber und ich finde irgendwie,
2:23
das ist so ein Klassiker und deswegen können wir einfach mal
2:25
mit diesem Klassiker einfach anfangen und durchstarten und
2:29
einfach mal gucken okay ne, was ist das, wann nutzt man das,
2:33
wofür benutzt man das? Und diese Fragen klären wir
2:36
einfach mal alle und zeigen natürlich, was es also wie das
2:40
aufgebaut ist, ne. Genau, also wir hatten ja
2:43
gesagt, dass wir uns heute das Factory Pattern anschauen
2:45
wollen. Und in der Einleitungsfolge sag
2:49
ich mal, haben wir ja auch gesagt, warum Pattern so wichtig
2:52
sind. Noch mal kurz genannt, um
2:54
einfach Strukturen den Code zu kriegen, besser testbaren Code
2:57
zu haben, Skalierbarer und Wartbarer zu sein und das kann
3:01
man am Factory Pattern auch ganz gut schon sehen und deswegen ist
3:04
es auch n super einstiegspattern sag ich mal, weil man kann es
3:08
auch mit. Mit Analogien gut erklären und
3:10
ich weiß, du bist Fan von Analogien.
3:12
Fabi, da kannst du dich richtig austoben heute aber mal ganz
3:17
kurz allgemein, warum überhaupt Factory pattern?
3:20
Also wir bewegen uns heute so n bisschen in der
3:22
objektorientierten Welt, das noch als Anmerkung dazu.
3:26
Ja. Und jeder, der vielleicht gerade
3:29
am Anfang ist, sich mit der Objektorientierung zu
3:32
beschäftigen, beispielsweise mit Javas startet und da ja
3:37
notgedrungen in die Objektorientierung kommt, was ja
3:40
nichts Schlechtes ist. Nicht falsch verstehen, aber der
3:42
wird das Halt merken, dass gerade am Anfang, dann hast du
3:45
überall New im Code, überall werden Objekte erzeugt, du weißt
3:48
gar nicht mehr, auf welchen du jetzt arbeiten sollst.
3:51
Du hast ne hohe Kopplung des Codes, du kannst das nicht mehr
3:54
so wirklich extrahierend voneinander und.
3:56
Wie sagt man so schön Dead escalated Quickly?
4:00
Also du kommst halt dann auch schnell an den Punkt, wo es
4:02
einfach unübersichtlich wird und da möchte ich wirklich mal mit
4:07
einer Analogie starten. Fabi, Ich hoffe du greifst die
4:09
auf oder hast vielleicht noch ne andere damit man sich das Ganze
4:12
einfach mal vorstellen kann wie man jetzt mit Hilfe eines
4:15
Factory Patterns. Mehr Struktur in seinen Code
4:19
bekommt. Und zwar möchte ich da, dass ihr
4:21
euch alle, liebe Zuhörer, liebe Zuhörer, du und vor allem auch
4:24
du Fabi euch folgendes vorstellt.
4:27
Ihr seid beispielsweise wieder in der Schule oder an der Uni,
4:32
ihr hattet eine anstrengende Vorlesung deswegen oder oder
4:38
gerade Unterricht und ihr seid so richtig ausgelaugt und was
4:40
wäre jetzt besser als ein kühles Getränk, weil es ist warm
4:43
draußen ja, also du hast jetzt so richtig Bock auf ein kaltes
4:46
Getränk und. Und dann steht er da, am Ende
4:48
des Ganges, leuchtend der Getränkeautomat, und du rennst
4:53
dahin mit deinen letzten Münzen in der Tasche und möchtest dir
4:56
jetzt noch ein schönes kaltes Getränk holen und stehst davor
4:59
und siehst die verschiedenen Knöpfe, weißt erst mal gar
5:02
nicht, was du nehmen sollst. Nimmst du eine Cola, eine Cola
5:04
light, ein Wasser, eine Apfelschorle vielleicht und eine
5:09
Spezi gibt es auch für dich kein Problem, hat der Automat am
5:13
Start und. Und ja, was passiert jetzt?
5:17
Du schmeißt dein Geld rein und drückst einfach auf n Knopf und
5:21
sagst zum Beispiel Wasser und du bekommst ne Wasserflasche
5:25
daraus, vorzugsweise wahrscheinlich n halber Liter
5:28
PET Flasche, aber du bekommst n Wasser.
5:32
Hättest du jetzt Cola gedrückt, würde der Automat dir Cola
5:35
geben. Das heißt abhängig davon, was du
5:38
dem Automat als Eingabe gibst, kriegst du dementsprechend den
5:42
Output. Ja, und das kann man sich jetzt
5:44
wieso n neues Objekt getränkt vorstellen, nur das ist in dem
5:48
Fall wenn ich Wasser drücke und Wasser ist wenn ich Cola drücke
5:50
ist es ne Cola. Das heißt, in diesem Fall ist
5:54
der Automat genau diese Factory und das Pattern, was wir heute
5:58
besprechen wollen. Denn die Logik was du bekommst
6:01
an Getränk, also als Getränk, ist quasi intern im Automat
6:06
gegeben und abhängig von deiner Knopfeingabe sagen wir mal da
6:10
drin ist ne Art Switch. Ja FLS wie auch immer.
6:15
Wird entschieden, welches Getränk ausgegeben wird.
6:17
Das heißt, für dich spielt es gar keine Rolle, wie intern
6:21
ausgewählt wird. Es spielt für dich nicht mal
6:23
eine Rolle, wie dieses Getränk da überhaupt rein gekommen ist.
6:25
Dass das irgendwer aufgefüllt hat oder wie das Getränk
6:27
abgefüllt wurde oder was auch immer es spielt für dich in dem
6:31
Fall keine Rolle, sondern es spielt nur eine Rolle.
6:34
Ich möchte jetzt auf Wasser drücken und dann möchte ich
6:36
bitte auch ein Wasser bekommen, der Rest ist mir egal und.
6:39
Und ich finde, daran kann man das schon mal ganz gut erklären
6:42
oder beziehungsweise verstehen, was dieses Pattern eigentlich
6:45
für n Ziel hat am Ende. Ja, also du kriegst ja im
6:48
Endeffekt sozusagen ein, wenn man jetzt so n bisschen, weil du
6:50
ja auf Switch und IF und so eingegangen bist.
6:52
Du kriegst ja am Ende so so ne Art, ich sag mal Objekt Getränk.
6:56
Und was es dann aber speziell für ein Getränk ist, das ist im
6:58
Endeffekt erstmal, sage ich jetzt mal egal, weil das dieser
7:02
Getränkeautomat kann nur Getränke ausspucken und dann ist
7:05
es natürlich wichtig. Was ist es denn wirklich
7:06
speziell für ein Getränk? Also wenn du jetzt zum Beispiel
7:09
sagst Wasser ist dann zum Beispiel auf 1 und dann hast du
7:11
zum Beispiel if Eingabe 1 dann Wasser if Eingabe oder Else IF
7:15
oder so und so weiter und sofort oder mit dem Switch wie du
7:18
meintest um sich das jetzt mal ganz explizit vorzustellen und
7:21
dann kriegst du halt einfach dein dein Getränk da raus.
7:23
Ja finde ich gut, ich finde das. Also ich hab hätt noch ne andere
7:27
Analogie, vielleicht noch mal so n bisschen um die Vielfalt
7:31
rauszubringen. Wenn wir jetzt schon bei Cola
7:34
und und ungesunden Getränken waren, dann möchte ich jetzt
7:36
noch n ungesundes Essen ansprechen.
7:38
Oh, jetzt bin ich gespannt. Zum Beispiel Pizza, ne.
7:41
Also wenn ihr jetzt zum Beispiel was.
7:43
Ungesund. Ja, natürlich nicht.
7:46
Pizza ist sehr gesund, sollte man jeden Tag essen, mindestens
7:50
3, mindestens 3, ja wenn nicht mehr, nein, auf jeden Fall, ich
7:56
finde, daran kann man sich das auch oder kann ich mir das ganz
7:58
gut vorstellen, wenn man sagt okay, du gehst in eine Pizzeria
8:01
und möchtest jetzt eine Pizza bestellen und du weißt
8:04
eigentlich okay egal welche Pizza du bestellst, du hast
8:08
eigentlich immer den gleichen Pizzaboden, also der Teig von
8:11
dem Boden ist immer der gleiche. Die Soße da drauf, die
8:15
Tomatensoße auch immer die gleiche, ne so und dann ist
8:18
natürlich nur die Frage OK, was möchtest du jetzt drauf haben?
8:22
Ne du gehst jetzt zum Beispiel hin du sagst ich möchte ne
8:23
Salamipizza bestellen, also bekommst du halt eben diese
8:26
Grundpizza ne Teig und Tomatensoße plus dann Salami und
8:30
Käse drauf ne oder du sagst ich möchte ne Hawaii Pizza haben und
8:34
bekommst dann halt eben wieder diese Grundpizza mit halt
8:37
Schinken und Ananas ich glaub so.
8:39
Ungefähr geht nach Hawaii, bin ich jetzt nicht so Fan.
8:41
Von Hawaii hast du doch nur gewählt, um jetzt hier Leute zu
8:44
provozieren, die sagen Hawaii ist keine Pizza.
8:48
Ja, mal gucken, finde ich gut, finde ich gut, gleich war so
8:52
eine Grundsatzdiskussion jetzt hier ausbrechen lassen.
8:56
Ja ich bin auch kein Fan von Hawaii muss ich sagen, aber ist
8:59
ja Geschmackssache, Geschmackssache.
9:03
Genau, aber im Endeffekt gehst du ja eigentlich dann am Ende
9:05
aber auch nur hin und ne, also wenn du das ganze noch weiter
9:07
abstrahierst, hast du ja in vielen Restaurants auch einfach
9:10
nur zahlen, die dann zu mich dran stehen und sagst ja ich
9:13
möchte jetzt die 10 ne und 10 ist dann am Ende beispielsweise
9:16
die Salami ne und dann sagst du ich möchte aber zu mich die 14
9:19
und das ist dann aber die die Hawaii und wichtig ist ja nur,
9:22
dass du weißt, du möchtest eine Pizza Punkt 1 und Punkt 2 ist
9:27
welche denn genau ne? Dann sagst du halt entweder den
9:31
Namen oder die Zahl und bekommst dann halt eben am Ende diese
9:33
Pizza. Und wie das jetzt aber
9:35
hergestellt wird, wie du meintest ne keine Ahnung, du
9:38
brauchst nicht wissen wie der Belag aussieht beziehungsweise
9:41
wie der wie der da drauf gelegt wird, wie die Pizzateig Rezeptur
9:45
ist, was in die Tomatensoße kommt alles egal.
9:48
Das macht alles die Küche ne und wenn man das jetzt auf Code
9:52
Ebene sieht, dann ist die Küche der Defactory und.
9:56
Innerhalb der Factory weiß der Code, was da passieren soll,
9:59
aber du von außen, wenn du die benutzt diese Factory die
10:02
brauchst, da brauchst du es nicht wissen, du willst halt nur
10:04
die entsprechenden Pits und so ne.
10:06
Und. Das ist im Endeffekt dann ja
10:10
auch eine andere Analogie für so n Factory patter ne.
10:14
Ja, was man daran auch wirklich. Also es ist auch n sehr gute
10:17
Analogie, vielen Dank dafür, fabi.
10:20
Weil wir ein wichtiger Punkt der ne Factory auch noch mit sich
10:24
bringt. Also das Pattern kann man daran
10:26
nämlich auch ganz gut erklären. Angenommen jemand bestellt jetzt
10:29
ne Salamipizza, fängst du ja nicht an zu sagen ich setze
10:34
jetzt n Teig an, ich rühre jetzt die Soße an oder stell diese
10:38
Soße quasi her, hab dann den Teig, die Soße und dann den
10:41
spezifischen Belag für die Pizza drauf, ne um ne Salamipizza zum
10:45
Beispiel herzustellen, sagen wir mal das machst du ja nicht in
10:49
dem Fall, sondern du hast ja wie du meintest diese Grundsoße, die
10:52
ist fertig für alle Pizzen, das heißt du kannst sie wieder
10:54
verwenden und musst nicht jedes Mal neu definieren, wie diese
10:58
Soße aussieht, welche Kräuter da reinkommen, wie auch immer,
11:01
genauso der Teig, der ist fertig, das heißt du musst nicht
11:03
jedes Mal wieder neuen Teig herstellen, nur um jetzt ne
11:06
Salami oder was hast du gesagt ne Hawai Pizza zu machen.
11:09
Ja und daran kann man nämlich auch gut erkennen welche
11:12
Vorteile das mit sich bringt, weil du kannst ja sagen ich habe
11:15
diese Grundpizza und die hat Eigenschaften.
11:17
Ja, zum Beispiel der Teig sieht so und so aus, die Soße da drauf
11:20
ist in der und der Menge da drauf und so weiter und darauf
11:24
aufbauend spezifizierst du dann ja nur noch wie du meintest die
11:27
Pizza und kannst so quasi Objekte schnell und einfach
11:32
herstellen, in dem Fall die Pizza.
11:34
Wenn wir jetzt noch mal n bisschen in die Coderichtung
11:35
gehen, also quasi in deiner objektorientierung Objekte
11:38
herstellen ohne zu wissen wie genau sie im Detail gebaut sind,
11:42
wie der Teig aussieht, wie die Soße aussieht, aber du weißt du
11:44
kriegst ne Pizza. Plus die Parameter, die du
11:47
reingibst Salami oder Hawaii oder ne Nummer wie du meintest
11:50
und hast dann am Ende n fertiges Pizzaobjekt, was deinen
11:55
Ansprüchen entspricht, sag ich mal.
11:57
Der Code liefert es dir einfach ne und das ist eigentlich
12:01
wirklich ne perfekte Analogie um einfach mal.
12:05
Den Factory Pattern zu zeigen, also quasi auch diese Analogie
12:08
mal zu programmieren, einfach sich zu sagen, ich habe jetzt
12:12
ein eine basisklasse Pizza und habe dann spezifische Pizzen
12:17
sozusagen die ich erzeugen kann, also alle, die jetzt diese Folge
12:21
hören und das mal ausprobieren wollen, programmiert ruhig
12:24
danach mal. Diese Pizzeria ist eine sehr
12:26
geile Übung. Was ich ein bisschen, also was,
12:29
was mich früher am beim Start in die Softwareentwicklung, was
12:33
mich immer so. Ein bisschen verwundert hat an
12:35
diesem, an dieser Beschreibung von einer Factory, das das
12:40
heißt, die Factory gibt ja ein Objekt und wie dieses Objekt am
12:45
Ende gebaut wird, das ist dir egal, das brauchst du nicht
12:49
wissen, das wird von der Factory bereitgestellt, das Macht der
12:52
Code dahinter und du brauchst das Wissen darüber nicht und das
12:56
fand ich da dachte ich mal so, ich verstehe es nicht ganz am
12:59
Anfang, da dachte ich mir, so wie ich bau.
13:02
Bau doch diese Factory, dann weiß ich doch wie das
13:04
funktioniert. So weißt du da dachte ich mir
13:06
immer so, das macht doch gar keinen Sinn.
13:07
Natürlich weiß ich wie das da drin aussieht, natürlich muss
13:10
ich wissen wie das passiert und das war für mich damals immer so
13:13
ein kleiner wie sagt man so, da habe ich mir so ein bisschen den
13:17
Kopf drüber zerbrochen, im Endeffekt ist es ja so, dass
13:21
wenn du normalerweise später irgendwann mal in der
13:25
Softwareentwicklung arbeitest, dann.
13:26
Dann schreibst du ja nicht den kompletten Code für die gesamte
13:29
Anwendung. Das heißt, du schreibst
13:31
vielleicht an einer Stelle und jemand anders schreibt an einer
13:33
anderen Stelle, das heißt, eine Person hat beispielsweise diese
13:37
diese Factory erstellt und du kannst sie dann für deine
13:41
Aufgabe nutzen. Und in dem Fall ist es dann so,
13:44
dass du natürlich darauf vertrauen solltest, dass die
13:46
Factory funktioniert. Ist ja auch deine
13:48
Arbeitskollegin oder dein Arbeitskollege, der das dann
13:51
implementiert hat, aber du kannst dann einfach nur sagen,
13:53
OK, ich möchte jetzt Objekt AB oder C haben und das kriege ich
13:56
aus der Factory raus, ne und das ist halt so n bisschen das war
14:02
ich weiß nicht ob noch irgendjemand vielleicht genauso
14:04
mal an diesem Punkt war, aber das das hat mich früher.
14:09
Gerade im Studium habe ich das immer.
14:10
Ich dachte, was wollen die denn von mir.
14:12
Natürlich weiß ich, wie das alles aussieht, ich habe es ja
14:14
programmiert. Dann, ja, natürlich ist damit ja
14:19
nicht gemeint, dass du eine Blackbox hast.
14:21
Also gerade wenn du sie selbst entwickelst, also das Pattern
14:24
selbst implementierst, geht es ja nicht darum, eine Blackbox zu
14:26
haben, wo du nicht in den Code reingucken kannst.
14:28
Aber um die Wiederverwendbarkeit und Skalierbarkeit, das ist ja
14:31
das Entscheidende, dass du genau diese Factory an einer Stelle
14:35
definierst. Und dann das Hochskalieren
14:38
kannst, indem du dir halt verschiedene Implementierung
14:41
einer Pizza überlegst oder implementierst und die dann halt
14:45
wieder verwenden kannst. Über deine Factory und das
14:48
Entschlankt oder macht ja den Code schlank am Ende
14:52
unvorinkalierbar. Ja, genau.
14:55
Aber es gibt halt auch, um mal ein bisschen fachlicher zu
14:58
werden und so mal richtig in das Design Pattern reinzukommen.
15:02
Es gibt ja verschiedene Formen des Factory Patterns, es gibt
15:05
sozusagen so eine vereinfachte Factory, es gibt die klassische,
15:09
was auch als Design Pattern so quasi in jedem Buch zu finden
15:12
ist. Und es gibt noch darauf
15:14
aufbauend eine erweiterte Form und die 3 würde ich gerne mal
15:18
jetzt der Reihe nach mit dir besprechen und.
15:21
Um einfach n guten Überblick zu geben und halt auch immer so n
15:23
bisschen vor und Nachteile und Use Cases zu nennen.
15:26
Und ich glaube dann haben wir hier im.
15:29
Vorfeld bevor wir jetzt wirklich in diese 3 Punkte einsteigen,
15:33
würde ich vielleicht noch mal ganz kurz n kleinen mini Exkurs
15:35
machen. Nur falls weil ich es könnte
15:38
sein, dass 2 bestimmte Begriffe fallen innerhalb dieser, wenn
15:41
wir das jetzt durchgehen. Und zwar einmal Interface, also
15:45
Schnittstelle und abstrakte Klasse, weil wir sind ja jetzt
15:48
wie wie du schon meintest, in Objektorientierungsebene und
15:52
damit man einmal vielleicht noch mal ganz kurz diesen ne, dass
15:57
man dann vielleicht noch mal alle abholt, bei denen es
15:59
vielleicht mal so n bisschen ins Grübeln kommt, so was war noch
16:03
mal ne Schnittstelle und das würde ich einmal ganz kurz noch
16:05
mal sagen und dann können wir direkt reinstarten also n
16:09
Interface ist im Endeffekt ja nichts anderes als eine.
16:12
Sammlung von Methodendeklaration also, dass du sagst, OK, du hast
16:15
jetzt zum Beispiel bei, wenn wir jetzt bei der Pizza sind bei
16:20
dieser ne, wenn wir jetzt von diesem Pizzabeispiel ausgehen,
16:23
dass du einfach sagst sowas wie mach Soße drauf, das ist eine
16:27
Funktion wo also ne die die da zum Beispiel irgendwie sinnvoll
16:31
wäre, weil du musst ja irgendwie Soße drauf machen, ne als
16:33
Beispiel und dann hast du vielleicht noch andere, aber du
16:37
hast im Endeffekt nur diese leeren Hüllen von Methoden, die
16:41
einfach so. Für jede Pizza angewandt werden
16:44
müssen und die dann aber für jede Pizza selbst implementiert
16:49
werden müssen. Also du sagst nur, das muss
16:51
passieren bei der Pizza, also du musst auf jeden Fall Soße drauf
16:54
tun, wie genau ist bei dem Interface nicht festgelegt, das
16:59
heißt du hast im Endeffekt nur du weißt nur was passieren soll,
17:02
aber du weißt nicht genau was passieren soll.
17:06
Also im Einzelnen. Und wenn du jetzt sagst, du hast
17:08
eine abstrakte Klasse, das ist ja ein bisschen ähnlich, kannst
17:11
du ähnlich verwenden, nur dass eine abstrakte Klasse zwar auch
17:15
sowas haben kann, wieso eine abstrakte Methode wo du sagst
17:19
okay es gibt keine Implementierung dafür, aber es
17:20
muss implementiert werden in der entsprechenden Klasse, aber es
17:24
gibt auch konkrete Methoden, also wo wirklich eine
17:27
Implementierung drin ist. Und wenn du jetzt zum Beispiel
17:29
das Gleiche mit einer Pizza machst kannst.
17:31
Könntest du zum Beispiel sagen, wenn du dieses Interface Pizza
17:34
hast, wo du sagst paktros Soße drauf, dann müsstest du, wenn du
17:37
2 verschiedene Pizzen implementiert, also
17:39
implementierst müsstest du bei jeder Pizza sagen okay pack mal
17:44
bitte Soße drauf, zum Beispiel eine Kelle und bei der anderen
17:47
zum Beispiel auch eine Kelle oder 2.
17:49
Wenn es mehr oder weniger sein soll, wenn du eine abstrakte
17:52
Klasse nimmst und dieses in dieser abstrakten Klasse, dass
17:55
die Methode packsoße drauf hast, dann.
17:57
Dann könntest du immer festlegen, weil wir auch vorhin
18:00
meinten, es ist immer die gleiche Menge.
18:02
Sagst du dort einfach, mach mal eine Kelle Soße drauf in dieser
18:05
Methode und dann kann quasi eine Salami Pizza kann dann im
18:10
Endeffekt eine Pizza sein und je nachdem ob es dann ein Interface
18:15
ist oder eine abstrakte Klasse, von der ich sag mal die
18:20
entsprechende spezifische Pizza ableitet oder erbt.
18:24
Hast du dann sozusagen die Möglichkeiten zu sagen, OK, muss
18:26
ich das immer selbst implementieren oder ist es
18:29
vielleicht schon an der einen oder anderen Stelle schon
18:31
vorimplementiert? Ja, also den Unterschied
18:35
zwischen Interface und der abstrakten Klasse sehen wir dann
18:38
auch in den Factory Pattern auch noch mal genau explizit sag ich
18:41
mal, weil das ist nämlich genau der Unterschied zwischen so
18:43
einer einfachen Factory und sag ich mal dem offiziellen Factory
18:46
Pattern. Ja, aber ja, es ist natürlich
18:49
ein wichtiger Unterschied und auch nicht so trivial, aber.
18:52
Also für also wenn man selbst halt manchmal so denkt, ja, ist
18:56
ja klar was n Interface ist, was ne abstrakte Klasse ist.
18:58
Nein, so klar ist das nicht gerade am Anfang nicht.
19:00
Deswegen gut, dass du es noch mal erwähnt hast.
19:02
Und ich weiß nicht, wie es bei dir ist.
19:04
Jedes Mal, wenn ich drüber nachdenke, muss ich auch erstmal
19:07
wieder drüber nachdenken. Also es kommt nicht so wie aus
19:09
der Pistole geschossen, dass ich sage ja, hier das und das,
19:11
sondern erstmal noch mal kurz im Kopf differenzieren und dann
19:14
quasi versuchen zu erläutern, das ist nämlich gar nicht so
19:17
trivial am Ende. Ich find was man sich auf jeden
19:19
Fall merken kann ist n Interface, da steckt niemals
19:21
Logik drin. Es sagt immer nur, was muss
19:24
passieren, aber nicht, wie es passieren muss.
19:26
Und bei einer abstrakten Klasse kannst du beides machen.
19:28
Du kannst einmal auf der einen Seite sagen, OK, was muss
19:30
passieren und du kannst aber auch noch zusätzlich sagen, wie
19:33
soll es denn genau konkret passieren, so das ist so n
19:36
bisschen das eigentlich das was man damit machen kann.
19:39
Also ich würde sagen ne abstrakte Klasse ist halt
19:40
mächtiger als n Interface. Ja genau, also in Interface kann
19:44
man sich halt merken, ist halt so ne Art Vereinbarung, sagen
19:47
wir es mal so, also es ist halt ne Definition.
19:49
Damit beide Seiten, die das verwenden, also der es erzeugt
19:53
und der es verwenden möchte, weiß, was drin sein wird.
19:57
So ne OK, aber dann lass uns direkt mal mit dem ersten Anfang
20:01
und zwar mit der simple Factory, weil da kommen jetzt auch
20:04
genauso die Interfaces zum Einsatz.
20:07
Also wie gesagt noch mal die Anmerkung, Es ist kein
20:09
offizielles Pattern, aber es ist sehr verbreitet und gerade am.
20:14
Anfang eines Projekts sehr einsteigerfreundlich, wenn man
20:17
so schon mal n bisschen was strukturieren will, aber
20:19
vielleicht noch nicht so ne Riesenkomplexität drin hat, dass
20:23
es nicht mehr ausreicht. Deswegen ist es eigentlich immer
20:25
n ganz guter Start damit anzufangen und man kann sich das
20:28
so vorstellen, dass man jetzt dieses simple Factory hat, also
20:31
eine zentrale Klasse. Die eine Methode bereitstellt
20:35
beispielsweise eine Create mit einem Eingabeparameter, also zum
20:38
Beispiel, wie wir bei der Pizzeria hatten, zu sagen, man
20:41
kippt noch rein, welche Pizza ja zum Beispiel als String kann man
20:46
ja machen. Ja, wenn du jetzt einfach sagen
20:47
möchtest Salami oder oder ne Nummer vom vom vom vom Menü
20:52
sozusagen und daran wird dann quasi entschieden was erzeugt
20:57
wird, das heißt diese Create gibt dir dann am Ende dein
20:59
Objekt zurück, was du haben möchtest, oder?
21:03
N anderer, n anderes Beispiel ne, was ich auch schon oft
21:07
gelesen hab und das macht auch Sinn, wenn du dir jetzt so zum
21:10
Beispiel vorstellst, du gehst Fastfood essen, ja du gehst
21:13
jetzt zu mcdonald's zum Beispiel, dann stellst du dich
21:15
ja auch an die Kasse und sagst ich hätt gern n Cheeseburger so
21:19
das wird aufgenommen. Der Satz Ich hätte gerne einen
21:22
Cheeseburger ist klar, die Küche weiß, was zu tun ist.
21:25
Ja, zum Beispiel jetzt und so. Factory mcdonald's Kitchen ruft
21:29
die Create auf und sagt Cheeseburger so, dann geht es in
21:32
der Küche zur Sache. Dieser Cheeseburger wird
21:34
hergestellt und zwar ist es und jetzt kommt ein Interface, ganz
21:38
klar wie n Cheeseburger auszusehen hat.
21:40
Ja also dieses Interface wurde für den Cheeseburger
21:43
implementiert, das heißt Brötchen keine Ahnung Patty.
21:46
Was kommt da? Kommt da überhaupt noch ne Gurke
21:48
drauf, keine Ahnung, klar das war da glaub ich noch nie drauf.
21:52
Nee, OK. Ja, Käse klar, Käse Käse wär gut
21:55
beim Cheeseburger. Ich hoffe, dass da Käse drauf
21:58
ist. Weißt du zugeklappt eingepackt
21:59
raus, du kriegst das und hast deinen wunderbaren Cheeseburger.
22:03
Vorteil an dieser Implementierung ist, dass es
22:07
halt schnell, einfach und übersichtlich erstmal ist.
22:09
Ne, weil du hast dann diese eine Funktion und du kannst dir
22:13
tausende Cheeseburger erstellen, damit ne du sagst ihn immer
22:15
wieder. Das hatte ich gerade gesagt.
22:18
Ja, mcdonald's Kitchen Punkt create gibt es Cheeseburger als
22:21
Parameter rein und du kriegst n Cheeseburger so der Nachteil ist
22:26
ist genau das was du nämlich jetzt gerade gesagt hast.
22:28
Aber jetzt möchte ich aber n normalen Hamburger jetzt möchte
22:30
ich oh Mann jetzt komm ich ins Schwimmen was gibt es bei
22:33
mcdonald's? Ja super super Mcchicken oder
22:36
wie die heißen ja also es gibt halt ziemlich viele Burger.
22:40
So, und da kommt nämlich dann der Nachteil, weil wir auch bei
22:43
den Getränkeautomaten meinten, man kann das ja zum Beispiel mit
22:45
einem Switch machen, nur dann kommst du halt relativ schnell
22:49
bei steigender Komplexität in die Switch.
22:52
Hölle also weil du einfach alle Fälle.
22:55
Sauber unterscheiden musst, weil du ja immer explizit diesen
22:58
einen Burger rausgibst und dieser eine Burger implementiert
23:02
quasi deine Schnittstelle wie es aussehen soll und definiert.
23:05
Das ist n Cheeseburger, das ist NN Big Mac gibt es n Big Mac so
23:09
Big Mac oder oder oder n Chicken Burger oder so ne ich find das
23:14
heißt. Ich muss das jeden type erkennen
23:16
ne also ich find es gut, dass du sagst auch es gibt n Burger
23:18
raus, weil am Ende sagst du ja ne irgendwie die Küche.
23:22
Create und dann zum Beispiel Cheeseburger, Hamburger oder was
23:25
auch immer. Was am Ende rauskommt ist ja ein
23:28
Burger, ne, du sagst ja du kriegst einen Burger und was
23:33
aber quasi der also du kriegst n Cheeseburger oder n Hamburger
23:37
der aber im Kern n Burger ist ne und wenn wir jetzt zum Beispiel
23:39
davon ausgehen, dass wir dann am Ende n Interface, also Burger
23:42
ist n Interface und du kannst halt sagen ja OK, der
23:45
Cheeseburger muss halt alle Methoden vom vom Burger quasi
23:50
implementieren. So, das heißt du weißt auf jeden
23:52
Fall auf einen Cheeseburger kommt, also dafür brauchst du
23:56
Brötchen, dafür brauchst du ein Patty, dafür brauchst du Soße
24:00
zum Beispiel und das ist bei einem Hamburger genauso.
24:02
Du brauchst auf jeden Fall auch wieder ein, also ein Brötchen
24:06
und du brauchst auch wieder ein Patty und du brauchst auch Soße,
24:09
es ist vielleicht was anderes je nach Burger und das ist halt
24:13
genau dann sozusagen. Dass du zwar sagst, OK, das muss
24:15
alles da sein, aber es muss einzeln implementiert werden in
24:19
den entsprechenden expliziten Klassen dann ne, also der
24:24
Cheeseburger weiß nur was passieren muss, aber wie genau,
24:27
das musst du im Cheeseburger festlegen.
24:29
So ne genau. Und da haben wir nämlich genau
24:32
das Problem. Wenn du jetzt sehr viele Burger
24:34
hast. Ja, also ich find das mcdonald's
24:35
Beispiel ist gar nicht so schlecht, weil das kann man sich
24:37
auch gut vorstellen, weil es noch n bisschen komplexer ist
24:40
als ne Pizza sag ich mal. Also komplexer im Sinne von der
24:42
Variantenvielfalt. Wenn du jetzt nämlich wirklich
24:46
grundverschiedene Burger hast und du gehst, aber das mit so
24:49
einem simple Factory Pattern Ansatz so wirklich ganz simpel
24:53
gehalten mit einfach so einer create Methode, ja dann hast du
24:56
halt das Ding, dass du wie du meintest, das Interface immer
24:58
neu implementieren musst. Ne, wie wird dieser Burger
25:01
hergestellt? Na ja, ich brauch das Brötchen
25:03
OK ich hol mir das Brötchen. Was brauch ich jetzt für n
25:05
Patty? Ja, Chicken Beef gibt es noch
25:07
was drittes? Nee ich glaub die beiden so, da
25:10
musst du da schon mal entscheiden ne und das muss ja
25:11
jeder Bürger für sich implementieren, damit der am
25:13
Ende dem entspricht wie er gedacht ist.
25:15
Sozusagen ne richtig und da merkt man schon das ist doch
25:19
viel doppelte Arbeit, ja. Wieso soll ich komplett neu
25:24
definieren, wie n Cheeseburger aussieht?
25:25
Wenn n. Hier gibt es doch auch so mit
25:28
Jalapenos so ne Chili cheese sag ich mal ne wenn der doch
25:32
eigentlich der gleiche Burger also geh ich jetzt mal von aus
25:34
der gleiche Burger ist nur, dass du nur noch n paar kleine
25:36
Jalapenos da drauf legst. Weißt du da muss ich das doch
25:39
nicht komplett neu definieren, wenn das der der gleiche Burger
25:42
eigentlich im Kern ist. So und da merkt man schon hm.
25:45
Das skaliert doch nicht. Also wenn ich jetzt wirklich ne
25:47
riesen burgerkarte hab, das wird nicht skalieren so ne und da ist
25:51
nämlich dann auch der Nachteil bei der Simple Factory, dass man
25:54
sagen kann, bei wenig Variantenvielfalt ist es schnell
25:58
und einsteigerfreundlich implementiert und ausreichend
26:00
völlig okay zu starten, weil Stichwort refactoring wenn du
26:05
merkst, ah nee, irgendwie mill ich meinen Code jetzt doch zu,
26:08
also das ist jetzt anstrengend, da diese ganzen Cases zu
26:11
unterscheiden, dann kann ich ja immer noch.
26:14
Refactan und vielleicht auf das eigentliche Factory Pattern
26:18
kommen und das würde ich jetzt gerne mit dir besprechen, um
26:21
einfach auch da mal den Unterschied zu zeigen und
26:23
welchen Mehrwert es bringt, auch wenn es natürlich Anmerkung
26:27
nicht ganz so einsteigerfreundlich ist, weil
26:29
es einfach ein bisschen mehr Aufwand hat.
26:31
Ja, also bisschen mehr Overhead an Code hat am Anfang ja ja auf.
26:35
Jeden Fall. Also wenn ich jetzt zum Beispiel
26:37
dieses Factory pattern, so wie es vielleicht dann auch
26:41
angedacht ist, nehme. Würde ich einmal kurz vielleicht
26:46
direkt den Unterschied zum zum simple Pattern mit dem Burgern
26:49
darstellen? Ne, weil wenn du dir jetzt zum
26:51
Beispiel überlegst, du hast in in diesem Burger, den du haben
26:55
möchtest, du meintest ja Cheeseburger und Chili
26:57
Cheeseburger ne, also es klingt ja schon fast gleich und bei dem
27:02
wenn wir jetzt noch mal dieses dieses Beispiel mit dem
27:04
Interface haben, dann steht ja in in dem Interface drin, du
27:08
brauchst ein Brötchen. So, und dieses Brötchen musst du
27:11
ja dann sozusagen im Cheeseburger definieren.
27:13
Also ne, du brauchst ein Brötchen, musst du da in ne
27:16
Logik reinpacken wie zum Beispiel Return?
27:20
Weiß nicht simple Bun oder so ne, also ein ganz normales
27:22
Brötchen und das gleich diesen gleichen, exakt gleichen Code
27:26
musst du ja noch mal im Chili Cheeseburger definieren, das
27:29
heißt du hast ja eigentlich quasi ne Code dopplung, die du
27:32
eigentlich nicht doppelt brauchst.
27:33
So und das bringt aber nun mal jetzt sozusagen so ein Interface
27:36
mit sich, wenn du sozusagen ne Factory über so ein Interface
27:40
nutzt, ne? So ein simple Factory.
27:43
Wenn du jetzt aber wirklich diese diese Factory patter
27:46
nimmst und sagst an der Stelle okay wir nehmen jetzt aber eine
27:49
abstrakte Klasse an dieser Stelle, dann können wir bei
27:53
einem sagen du hast einen Chili Cheeseburger und du hast einen
27:56
Cheeseburger und das Ganze hat eine abstrakte Klasse, von der
28:00
geerbt wird sozusagen, die ist einfach ein Burger und dieser
28:05
Burger hat nimm ein Brötchen und ich.
28:09
In dieser Burger Klasse, in dieser abstrakten Klasse ist
28:12
schon definiert, dass du für deinen Burger, für die also
28:16
einmal den Cheeseburger und den Chili Cheeseburger jeweils das
28:19
normale oder das einfache Brötchen nimmst.
28:21
Und damit hast du diese Implementierung schon in der
28:24
abstrakten Klasse drin und musst es nicht zweimal im Cheeseburger
28:28
und im Chili Cheeseburger sozusagen implementieren.
28:31
Und das hilft dann halt sozusagen bestimmte.
28:35
Eigenschaften schon zusammenzufassen, um halt eben
28:37
diese Codeduplikation zu vermeiden.
28:40
Wie du meintest, weil stell dir vor, du hast n burgerrestaurant,
28:44
ne was du jetzt in in weiß ich irgendwie programmierst in einem
28:47
Game oder so wo immer der Gleiche es sind immer nur die
28:51
gleichen Burgerbrötchen ne du hast niemals andere
28:53
burgerbrötchen, da macht es keinen Sinn.
28:55
In 20 Bürgern beispielsweise wirklich 20 mal den gleichen
28:59
Code zu machen. Ich mein, da kommt man ja
29:00
relativ schnell hin und denkt sich so okay irgendwie müsste
29:02
ich das ja vielleicht vereinheitlichen können.
29:04
Genau, nimm ne abstrakte Klasse und kein Interface an der Stelle
29:08
um das jetzt mal so direkt im Vergleich zu sehen, ne.
29:12
Genau. Und dann dann quasi alle, die
29:14
dann so richtig auf Vererbungen in der Objektorientierung
29:17
stehen, die können das natürlich bis auf die Spitze treiben, dass
29:19
du sagst, ich hab ne klasse Burger, die ist abstrakt, ne und
29:22
dann gibt es n Cheeseburger und den kann ich auch noch mal
29:25
weiter vererben zum Chili Cheeseburger, der eigentlich nur
29:28
n Cheeseburger ist, wo ich am Ende halt wie gesagt noch
29:30
lalapenos drauf mache oder irgendeinen anderen Burger, wo
29:33
auf einmal Salat und Tomate drauf ist oder irgendwie so.
29:35
Also du kannst das ja immer weiter Kapseln sozusagen und das
29:40
Factory Pattern dann halt so richtig ins Spiel bringen, sag
29:43
ich mal. Aber ich find n anderes
29:45
Gedankenspiel dabei auch noch gut, um sich das noch mal
29:48
vorzustellen, wofür so n Factory Pattern auch gut ist.
29:51
Wir haben ja jetzt gesagt, du hast n burgerladen ja,
29:55
mcdonald's als Beispiel, jetzt ist mcdonald's vielleicht sehr
30:00
standardisiert. Länderübergreifend, so wie ich
30:03
es jedenfalls kenne. Also wahrscheinlich wird es
30:05
schon Unterschiede geben, auch wahrscheinlich in den, es ist ja
30:07
irgendwo n Franchise am Ende, das heißt du hast wahrscheinlich
30:09
auch n bisschen andere Karten oder Aktionen whatever aber es
30:12
ist schon so standardisiert, dass ich glaub ich würd ich
30:15
jetzt mal sagen, so n cheeseburger.
30:17
In fast jedem Land gleich ist ne.
30:19
Das heißt, das wäre ja auch wieder so n bisschen Richtung
30:22
Simple Factory, auch wenn es halt wie gesagt zu viele
30:25
verschiedene Burger gibt, aber da würde das ja noch so halbwegs
30:27
funktionieren zu sagen, Hey Cheeseburger ist doch immer
30:30
gleich, ja brauch ich es auch wirklich nur einmal machen, aber
30:33
wenn man das n bisschen allgemeiner formuliert und ich
30:35
hab jetzt einfach n Burger ne Burger Kette oder n Burger laden
30:40
ne wo ich einfach gut Burger essen gehen kann ja dann sieht
30:43
ja dieser Laden oder? Sagen wir mal so, ich möchte
30:48
einfach einen Burger bestellen und ich gehe jetzt in
30:50
verschiedenen Ländern in einen entsprechenden Laden und kaufe
30:54
mir einen Burger, dann sieht er ja natürlich beispielsweise im
30:58
asiatischen Raum anders aus als im in der USA zum Beispiel ja,
31:02
in der USA ist die Wahrscheinlichkeit ja schon
31:04
groß, sowas Big Mac Artiges zu bekommen.
31:08
In im asiatischen Raum wahrscheinlich eher irgendwas
31:11
asiatisch angehauchtes, ja vielleicht irgendwie so mit
31:14
tiriyaki Soße in Japan oder so. Keine Ahnung, was geiles halt so
31:17
ne, aber am Ende sind beides Burger, sind aber grundlegend
31:21
verschieden. Also wie willst du jetzt
31:23
anfangen mit einer simple Factory das alles abzubilden?
31:26
Das heißt da kommst du halt jetzt zu den offiziellen Pattern
31:29
zu sagen es gibt ne abstrakte Burgerklasse ne es gibt
31:32
Grundeigenschaften eines Burgers, aber je nach Land.
31:36
Sind die Spezifikationen obendrauf anders?
31:39
Ja, für diesen Burgerladen, das heißt, meine Factory ändert sich
31:42
dementsprechend auch oder die Burger, die ich damit erstellen
31:45
kann, dass ich zum Beispiel sagen kann, hey, ich hab ne
31:48
Factory und ich möchte jetzt n Burger und ich bin in Japan zum
31:52
Beispiel und dann kriegst du halt deinen teriyaki Burger, ja
31:54
oder ich sag, ich bin jetzt in der USA und Du kriegst halt n
31:57
Big Mac so aber unter der Haube sind das abstrakte Burger, die
32:01
selbst implementieren zum Beispiel deine Big Mac Klasse
32:05
Teriyaki Burger Klasse. Ich hab keinen besseren Namen,
32:08
sorry, und da hast du jetzt den Vorteil, dass die eigentliche
32:12
Erstellung ja wie das Objekt am Ende aussieht, dann in deinen
32:16
Subklassen ist. Das heißt, die Factory hat jetzt
32:19
nicht mehr die Logik sowas wie OK, das Interface ich returne
32:25
jetzt das Interface mit den und den Funktionen oder den und den
32:27
Werten ja, sondern ich geb jetzt ne Subklasse zurück wie Big Mac
32:32
Burger. Ja, weil die Factory wurde jetzt
32:36
aufgerufen, mit Burger in der USA, Mhm so und dann geb ich ne
32:40
Big Mac Klasse zurück und die Klasse selbst definiert jetzt
32:43
wie der Burger ist und nach außen ist es dann halt wirklich
32:45
nur noch dieser abstrakte Burger.
32:47
Erstmal ja so und das ist halt der große Vorteil, dass du halt
32:51
so komplexe Abläufe damit dann auch implementieren kannst.
32:56
Zum Beispiel sowas wie. Länderabhängig Länderabhängig
33:00
ist, weißt du ja. Ich meine, das ist ja, wenn man
33:04
sich das zum Beispiel noch mal im Vergleich vorstellt, und du
33:06
hast jetzt ein bisschen ein leicht abstrakteres Beispiel, du
33:11
hast jetzt zum Beispiel ein Interface, ne, weil du ja
33:13
meintest, das macht damit nicht so viel Sinn und stell dir vor,
33:16
du hast am Ende ein Interface, wo alle Objekte eigentlich nur
33:20
eine Methode teilen, die sie auf jeden Fall alle haben, und dann
33:23
aber zum Beispiel Objekt 1, ne, was du instanzieren möchtest.
33:27
Hat dann aber 5 Funktionen von der von dem Interface noch und
33:33
klasse 2 noch mal 5 andere. Das heißt du hast in deiner in
33:36
deinem Interface 11 Funktionen, aber für die eine Klasse
33:39
brauchst du eigentlich nur die Hälfte und für die andere auch n
33:42
bisschen mehr als die Hälfte. Du hast also ne minimale
33:45
Schnittmenge und denkst dir so, warum hab ich eigentlich n
33:47
Interface mit so vielen Funktionen die ich aber am Ende
33:50
gar nicht implementieren muss? Also du musst sie quasi
33:53
implementieren, was sind leerimplementierungen dann und?
33:56
Und du denkst ja so, die brauch ich da ja gar nicht drin.
33:58
Ne und das macht es dann an der Stelle irgendwann einfach nicht
34:01
mehr sinnvoll, sozusagen so n simple Factory Pattern zu
34:04
verwenden, sondern dann halt eben dieses Standard Factory
34:06
Pattern zu nutzen. Ne und ich find das ja, wenn wir
34:11
jetzt das Ganze noch mal vielleicht n bisschen
34:12
technischer erklären, weil mir bringt das manchmal auch
34:17
irgendwie was, wenn ich mir dann denke so OK, ja gut, wann
34:20
implementier ich denn jetzt mal ne ne Burger factory, weißt du?
34:25
So, wo wird denn das? Überhaupt, ich hab jetzt genug
34:27
über Burger geredet, ich hab erstmal Hunger, nur Pause ein.
34:33
Aber zum Beispiel, wenn man jetzt sagt, du hast einen.
34:36
Ich bestell auch Grad nebenbei. Was willst du auch was?
34:39
Ja komm. N.
34:40
Cheeseburger und n Chili cheese würde ich gerne lesen.
34:44
Wenn du jetzt aber pass auf wenn du jetzt sagst du hast ne UI
34:47
oder so ne und du sagst ich möchte jetzt du hast ne Factory
34:51
wie wie du sie gerade beschrieben hast.
34:54
Mit einem Button so und dann möchtest du einfach nur zum
34:57
Beispiel einen Button haben und jetzt ist aber die Frage, auf
35:01
welchem Betriebssystem hältst du dich denn gerade auf, weil jeder
35:05
weiß das ja, dass zum Beispiel auf einem Mac das Ganze
35:08
vielleicht ein bisschen anders aussieht als auf einem Windows
35:11
PC, die UI oder vielleicht auch bei einem Linux oder?
35:14
Und damit du dann aber im Endeffekt sagst, ich möchte nur
35:17
diesen Button, aber unabhängig davon, also ich möchte ja gar
35:20
nicht, mir ist es egal welche auf welchem Betriebssystem ich
35:23
mich befinde, diese Factory soll mir einfach den richtigen Button
35:27
zurückgeben, den ich dann einfach meine UI einsetzen kann.
35:31
Ja, das ist ein gutes Beispiel, weil ja der Button unabhängig
35:35
vom Betriebssystem am Ende die gleiche Funktion haben wird oder
35:39
die gleichen Fähigkeiten. Attribute nenn ich es mal ne.
35:43
Aber ich natürlich im Betriebssystem Style bleiben
35:47
möchte. Gerade wenn ich jetzt so Cross
35:48
Plattformen entwickle. Ja und ich sage, ich habe jetzt
35:50
zum Beispiel ne Desktop application und ich möchte die
35:52
aber auf eingängigen Betriebssystem anbieten können,
35:55
dann macht es natürlich Sinn wie du gerade meintest erstmal zu
35:58
gucken auf welchem Betriebssystem läuft diese
36:01
Anwendung und dementsprechend Style ich sie oder baue sie wie
36:05
auch immer an welchem Step wir jetzt sind ja und?
36:08
Das ist halt n cooles Beispiel, weil unter der Haube ist es ja
36:11
der gleiche Button. Am Ende ne, der hat dann zum
36:13
Beispiel irgendein Callback, wenn du ihn drückst der
36:15
implementiert werden kann und das hat ja bei allen
36:17
Betriebssystemen nur dass er halt vielleicht vom Styling
36:19
anders aussieht. Richtig.
36:20
Und dann hast du sozusagen das Styling, ist unterschiedlich in
36:23
den eigenen Klassen, aber dieser Callback, wie du ihn zum
36:25
Beispiel gerade genannt hast, oder die Funktionalität, die
36:27
dahinter steht n bisschen abstrakter.
36:29
Ist dann halt eben in der Basisklasse vertreten.
36:31
Ne und und weil es ist ja immer das Gleiche dann für diesen
36:34
entsprechenden Button, sagst zum Beispiel N submit Button und
36:36
dann kriegst du halt wirklich diesen submit Button
36:38
unterschiedlich gestylt, je nachdem Betriebssystem aber die
36:41
gleiche Funktionalität, ne das ist auf jeden Fall dann der Sinn
36:45
dahinter. Das heißt, um das noch mal
36:48
technisch sich vorzustellen, man hat dann im Code zum Beispiel ne
36:51
Klassenabstrakte Klasse Button und die Implementierung davon
36:54
wäre dann zum Beispiel N Windows Button oder N Linux Button.
36:57
Ja, und die Factory gibt dir den abhängig von dem Betriebssystem,
37:00
auf dem du bist. N Windows Button oder N Linux
37:03
Button um es so n bisschen konkreter zu machen.
37:05
Und ja da sieht man ja eigentlich schon die die
37:08
Vorteile einer Factory. Ja also du hast halt diese
37:10
Austauschbarkeit, ne, das heißt mit jeder Subklasse die ich
37:14
implementiere kriege ich halt auch so ne neue Implementierung
37:16
rein ohne die anderen anrühren zu müssen.
37:19
Ganz wichtiger Punkt ja wenn ich das Styling am Linux Button
37:22
ändern muss ich nichts am Windows Button machen weil der
37:24
soll ja auch bleiben wie er ist. Das heißt, ich muss da am Code
37:26
nicht drin rumrühren und kann halt potenziell Fehler einbauen.
37:30
Das heißt, die Austauschbarkeit ist halt auch gegeben, ne, wenn
37:35
zum Beispiel der Linux Button einfach ganz anders aussehen
37:37
soll oder vielleicht gar nicht mehr drin sein soll, oder dazu
37:39
kommt, du kannst es halt einfach nebeneinander halten sozusagen,
37:43
das heißt es ist auch besser testbar und wartbar ne wenn ich
37:46
n Test schreibe für den Windows Button und den Linux Button
37:49
änder, dann hab ich halt am Windows Button Test natürlich
37:51
auch immer noch grün, hoffentlich am Ende ne wenn ich
37:53
es richtig implementiert habe das heißt?
37:55
Wir haben halt keinen zentralen Code mehr, der alles wissen
37:58
muss, sondern wir lagern es auf die Subklassen aus, was laut
38:03
Objektorientiert einfach denn sauber getrennt ist.
38:05
Ja, definitiv. Und im Endeffekt.
38:12
Also es gibt natürlich auch Nachteile, es ist ja nicht immer
38:14
nur so, dass es da die ganze Zeit immer nur ne Vorteil
38:16
Vorteil, Vorteil, du brauchst natürlich n komplexeres Setup
38:20
irgendwo ne, also du hast natürlich jetzt.
38:23
Also dein ganzer Code wird natürlich komplexer an dieser
38:26
Stelle, weil du zum Beispiel ne, gerade wenn du sagst, du hast
38:28
mehrere Objekte von einer, also die, die zusammengehören zu
38:33
einer Familie, ne, dann brauchst du halt so ne so ne basisklasse,
38:37
die dir sagt, OK ne, meine ganzen Bürger sind am Ende n
38:40
Bürger ne die verschiedenen. Wenn du jetzt aber das ganze
38:43
noch länderspezifisch spezifisch aufteilst, dann hast du
38:46
verschiedene. Burger, die zum Beispiel keine
38:49
Ahnung, amerikanische Burger sind.
38:51
Du hast Burger, die aber asiatische Burger sind, ne, und
38:54
dann hast du wieder diesen diese beiden Burger Varianten, die
38:57
aber am Ende auch wieder nur Burger sind, das heißt du holst
39:00
dir natürlich ne höhere Komplexität, ne höhere Tiefe, ne
39:03
in deinen Code rein. Und das kann natürlich auch dazu
39:07
führen, dass es vielleicht n bisschen schwieriger am Anfang
39:10
durchzublicken ist. Ne.
39:11
Deswegen heißt das andere ja auch simple Factory, weil es
39:14
halt eigentlich eher n bisschen flacher Gehalt, also diese ganze
39:18
Hierarchie n bisschen flacher hält.
39:19
Aber wie gesagt, hier macht es mehr Sinn, wenn es auch n
39:22
bisschen generell, wenn wenn diese ganze Abhängigkeit
39:25
komplexer wird, dann also ne mit einer höheren Komplexität steigt
39:28
meistens halt auch die Komplexität des Codes.
39:30
Ja, es ist natürlich ratsam, immer zu gucken.
39:33
Je höher also auch, wenn die Komplexität steigt, Krieg ich es
39:36
vielleicht doch mit möglichst wenig Komplexität in meinem Code
39:39
hin, aber ab einem ab einer gewissen Ebene kommt man halt
39:43
einfach nicht da dazu, dass man halt eine gewisse Komplexität
39:47
vermeiden kann. Ja, und das ist auch ein gutes
39:51
Stichwort, Komplexität, und das wäre so im Prinzip die dritte
39:54
Stufe. Von den Pattern ist dann die
39:57
sogenannte Abstract Factory, das heißt, wir fangen jetzt quasi
40:02
noch an, uns zu überlegen. OK, ich hab ne Factory und ich
40:06
kann jetzt zum Beispiel länderspezifisch den Burger
40:09
Design ne, also beispielsweise ich möchte n cheeseburger haben
40:13
und der sieht halt wie gesagt in Japan anders aus als in der USA.
40:16
So das können wir jetzt schon ganz gut abbilden.
40:19
Wie sieht das jetzt aber zum Beispiel aus, wenn wir ganze
40:21
Produktfamilien haben und da kommt dann die Abstract Factory
40:24
ins Spiel, das heißt, wir haben Produktfamilien, die
40:27
Zusammengehörig sind, und das kann man an dem Beispiel, wir
40:30
sind wieder bei dem Burger auch wieder gut erklären, weil ich
40:33
hab jetzt nicht nur Bock n Burger zu essen, ich fühle es,
40:36
ich möchte n Menü haben, ja. Ja.
40:40
Und. Habe jetzt quasi Burger, eine
40:42
Beilage und ein Getränk. So und das alles natürlich so
40:47
wie ich es erwarte im Stil des Restaurants, wo ich gerade
40:50
bestelle, ja sagen wir mal zum Beispiel bei einem Cheeseburger
40:57
in Amerika kriege ich halt so klassisch Doktor Pepper Cola
41:01
keine Ahnung und Fries und in Japan zu meinem Teriyaki Burger
41:07
will ich jetzt nicht unbedingt eine Doktor Pepper dazu haben,
41:09
sondern ich kriege. Ah, Klischee, auf keiner Matcha
41:12
Tee oder so. Weißt du also was ich damit
41:14
meine ist, du hast ja im Prinzip die Menüs die angeboten werden
41:20
von dem Restaurant sind natürlich auch spezifisch und im
41:23
Stile ihres Restaurants ja also. Da, das wird sich ja denn
41:27
grundlegend als gesamte Produktfamilie Burger Menü
41:31
unterscheiden und da kommt halt denn die Factory ins Spiel, die
41:35
Abstract Factory, die dann wiederum deine Factory so
41:39
definiert, zum Beispiel, dass du sagst, ich bin in Japan oder in
41:42
der USA und dafür sorgt, dass die einzelne Produkte, die jetzt
41:48
ne Factory intern bereitstellen kann sowas wie gib mir einen
41:52
Burger, gib mir eine Beilage, gib mir ein Getränk.
41:55
Dafür sorgt, dass es in sich zur gleichen Produktfamilie gehört,
41:59
dass ich halt nicht sage, ich Krieg n amerikanischen Burger
42:02
und ne japanische Beilage zum Beispiel, das wär auch Wahnsinn,
42:06
das wär Wahnsinn, das nennt man Fusionsküche.
42:09
Fusionsküche genau, aber weißt du, wie ich meine?
42:13
Und ich finde, da kann man das eigentlich ganz gut dran
42:14
erkennen, denn oder beziehungsweise verstehen, warum
42:17
man diesen Schritt auch noch. Geht ja.
42:19
Wenn wir jetzt zum Beispiel noch mal dieses UI Beispiel von
42:21
vorhin nehmen, ne und das noch zum Beispiel auch noch mal daran
42:24
erklären, noch mal in die Technik n bisschen so
42:28
abzutauchen ein wenig, dann ist es ja so, dass du zum Beispiel
42:32
sagst, ich möchte jetzt ein, also meine UI Elemente haben,
42:36
ne. Also nicht nur einen Button,
42:38
sondern ich möchte vielleicht auch noch eine Checkbox haben
42:40
oder ich möchte was gibt es noch einen Radio Button haben oder
42:44
was auch immer, so verschiedene Elemente, die aber auch wieder
42:47
logischerweise entsprechend gestylt sind.
42:49
Du kriegst ja nicht einen Mac Button in Windows Checkbox und
42:55
eine Linux Radio Button, das wird ja im Endeffekt, also
42:59
kannst du auch machen, wäre aber irgendwie blöd.
43:01
So, und dann ist es halt im Endeffekt so, dass du halt
43:04
abhängig vom Betriebssystem dir diese Familie holst.
43:08
Von Ui Elementen, von denen du dann wiederum ein spezifisches
43:13
brauchst. Und im Endeffekt kann man sich
43:15
das so vorstellen, dass Du eine Factory hast, die anhand des
43:20
Betriebssystems und also unterscheidet, wenn.
43:23
Welche Factory sie dir gibt, um den entsprechenden Einzelnen,
43:27
das einzelne Ui Element zu bekommen.
43:29
Das heißt du hast eine Factory die dir eine Factory ausspuckt,
43:31
die dir dann am Ende wieder ein Objekt gibt.
43:35
Genau also im Prinzip. Das ist ein gutes Beispiel, und
43:39
wenn wir jetzt noch mal so auf auf die Ui Elemente gehen, du
43:42
definierst ja nicht jedes Mal. Also du, du erzeugst dir jetzt
43:46
ja nicht eine Factory für Buttons und sagst jedes Mal wenn
43:48
Du einen Button haben möchtest übrigens Windows.
43:51
Und jetzt gib mir noch ne Checkbox.
43:53
Übrigens Windows ja und dann machst du irgendwann den Fehler.
43:56
Übrigens Linux. Ach verdammt weißt du und
43:59
deswegen gehst du quasi diesen Weg mit der Abstract Factory und
44:03
sagst gib mir ne UI Factory Windows und die kann dir jetzt
44:08
sagen create Button, create checkbox und es wird immer.
44:13
Windows sein am Ende, weil du das unter der Haube quasi so
44:16
definiert hast. Und dann musst du dir bei der
44:18
Anwendung oder bei dem Erstellen der Objekte darüber keine
44:21
Gedanken mehr machen und das bringt halt mehrere Vorteile mit
44:24
sich. Also erstmal, es ist konsistent,
44:26
ja wie du gerade meintest, es passt alles zusammen,
44:29
beispielsweise wenn ich betriebssystemabhängig bin.
44:32
Es ist super testbar. Ich kann die einzelnen
44:34
Betriebssystem Stylings abtesten es ist austauschbar, ne, weil es
44:38
muss ja nicht nur Betriebssystem abhängig sein, so ein
44:41
klassischer Anwendungsfall sind ja auch so Themes sage ich mal
44:46
ne habe ich ein helles Layout, habe ich ein dunkles Layout und
44:49
ich möchte ja nicht bei jedem UI Element sagen, übrigens du bist
44:51
gerade ein dunkles Layout oder ein helles Layout nein du willst
44:55
es ja global irgendwo entscheiden und dann einfach
44:57
darauf arbeiten sozusagen oder wenn du eine Testumgebung
45:01
erzeugen willst dann. Willst du ja auch sagen, gib mir
45:04
mal meine Test Factory, ich will jetzt da was ausprobieren, zum
45:07
Beispiel also das das bringt halt viele Vorteile mit sich
45:10
schnell austauschbar auch zu sein.
45:13
Ja Nachteil glaube ich kann man eigentlich ganz schnell erklären
45:16
oder komplex. Ja klar, das ist natürlich die
45:21
komplexeste Variante von allen Factories.
45:23
Und wie gesagt, ich ich persönlich würde auch darauf
45:27
verzichten, wenn es nicht notwendig wäre, ne, also diese
45:30
dritte Variante. Was ich noch sagen würde ist,
45:34
weil das ist zum Beispiel auch n Punkt, der hat sich früher
45:37
irgendwie ganz am Anfang von meinem Studium.
45:39
Zum Beispiel hat sich auch nicht so richtig erschlossen und ich
45:42
würd das auch vielleicht noch mal so, weil ich denk mir so,
45:45
vielleicht hat man mal das Problem gehabt, was vielleicht
45:47
andere auch haben oder das Verständnisproblem, man kann
45:50
sich ja jetzt hinstellen und sagen, was bringt denn
45:52
eigentlich so ne Factory, wieso sag ich jetzt zum Beispiel nicht
45:54
einfach ey, dann erstelle ich mir n neues Objekt davon und
45:56
dann mach ich damit was und da an einer anderen Stelle nehm ich
45:59
mir halt n anderes Objekt. Ne was ich da halt vielleicht
46:02
brauche und dann mache ich das halt ne, weil du ja meintest am
46:05
Anfang um noch mal den Bogen zum Anfang zu schießen.
46:08
Du hast dann überall mal New Objekt von dem New Objekt von
46:11
dem mach mal dies mach mal das ne und wenn du dir jetzt zum
46:14
Beispiel vorstellst du hast n ne Anwendung auf deinem eigenen
46:18
Server laufen und du sagst zum Beispiel OK ich möchte aber
46:20
diesen Server, also ich möchte meine Anwendung überwachen und
46:25
du hast jetzt zum Beispiel du fängst an und sagst OK ich
46:27
möchte jetzt. Diese, wenn irgendein Problem
46:30
auftritt, möchte ich zum Beispiel mich selber
46:32
notifizieren, ne mit einer e Mail so dann mach ich, erstelle
46:38
ich irgendwie mir so NE Mail notifier und sag send mal die
46:42
notification raus über die e Mail ne so und dann hast du aber
46:46
vielleicht irgendwann denkst du dir so oh e Mail wirklich, das
46:48
ist einfach da ich ich guck nicht immer so oft in die e
46:51
Mails ich brauch das vielleicht als SMS oder so ne so das heißt
46:54
du sagst ey ich erstell mir jetzt noch n.
46:56
Weiteren Notifire, nämlich einen SMS notifire und sende dann
46:59
sozusagen noch als SMS raus. So, und wenn du jetzt aber
47:02
irgendwann sagst, weiß nicht SMS, ich habe manchmal irgendwie
47:05
bin in einem Funkloch, aber Internet habe ich irgendwie, ich
47:07
brauche das auch noch für eine App als push Nachricht, dann
47:09
machst du noch einen Push notifire so ne, dann hast du 3
47:12
verschiedene Notifire, die du aber alle in diesem wenn jetzt
47:16
zum Beispiel ein Fehler in deinem in deiner Anwendung
47:18
auftritt, möchtest du über alle notifire dich notifizieren,
47:21
damit du auch wirklich mitkriegst.
47:23
Es ist ein Fehler aufgetreten im System ne.
47:26
Und egal, wo du dich gerade aufhältst, entweder du hast kein
47:28
Internet oder du hast einen Netzausfall oder du hast gerade
47:31
keine Ahnung, mal wieder nicht in die e Mails geguckt, irgendwo
47:34
willst du es halt herkriegen diese Information und dann
47:37
möchtest du deinem Code aber nicht sagen, create new e mail
47:40
notifeier und sende create new SMS notifeier und sende create
47:46
new push notifeier und sende ne, das müsstest du ja für jeden,
47:49
für jedes immer wieder noch mal neu machen.
47:52
Und wenn du jetzt aber sagst, ein e Mail notifier und eine SMS
47:55
Notifier und Push notifier sind alles irgendwo notifier ist
47:58
jetzt egal welche Factory an der Stelle und wie das genau
48:00
implementiert ist. Aber du kannst dann zum Beispiel
48:03
wenn du noch ein Notifier hinzufügen möchtest, kannst du
48:06
alle in eine Liste von Notifier packen und dann mit einer vor
48:10
darüber gehen und einfach sagen okay notifier send so, das heißt
48:14
du hast einen viel eleganteren Code am Ende als immer zu sagen.
48:18
Also du musst natürlich diesen Notifire dann über deine Factory
48:21
die entsprechenden Notifire erstellen und einen neuen
48:24
hinzufügen. Du musst aber nicht jedes Mal
48:26
sagen okay, ich mache das jetzt für jedes erstelle ich ein neues
48:29
Objekt und so weiter und sofort, sondern du nutzt immer nur die
48:31
Factory sagst du möchtest ein bestimmtes neues Ding haben,
48:35
kriegst es dann packst es in die Liste und wenn du jetzt zum
48:38
Beispiel sagst, du hast eine Liste und in vielen Sprachen die
48:40
jetzt auch Typsicher sind, kannst du ja nicht sagen, ich
48:43
erstell eine Liste von einem Objekt.
48:45
E Mail notifire von dem Objekt SMS Notifire und von dem Objekt
48:49
Push notifire weil es sind 3 unterschiedliche Objekte.
48:51
Wenn du aber sagst das sind alles notifire, dann kannst du
48:54
ne Liste von Notifirern erstellen und dann darüber
48:56
iterieren und das sind manchmal so dann die Vorteile die das
49:01
dann am Ende mit sich bringt. So weißt du so Kleinigkeiten wo
49:04
ich am Anfang wo ich mir weißt du das ist immer so bescheuert
49:08
so am Anfang des Studiums dachte ich dann so was wie ja was
49:10
brauche ich das ich verstehe den Anwendungsfall noch nicht und
49:13
irgendwann kam ich an den Punkt wo ich mir dachte das ich würd
49:15
das jetzt gern alles in eine Liste packen aber es geht nicht
49:18
und dann irgendwann kam so diese Connection wo ich mir dachte Oh
49:22
ne Factory weißt du und das kann man halt wie gesagt ist
49:27
unabhängig vom Typ der Factory kann man mit allen machen, die
49:31
Implementierung ist dann sei mal dahingestellt, da haben wir ja
49:34
auch schon n paar Beispiele genannt, aber das ist zum
49:36
Beispiel finde ich n sehr sehr wichtiges Beispiel um zu zeigen
49:40
so kannst du ne Factory nutzen als genau.
49:44
Es hält halt den Code schlank, dann am Ende alright.
49:48
Genau dann hatten wir ja noch n konkretes Beispiel am Ende dann
49:51
würde ich sagen lass uns doch mal noch mal kurz
49:52
zusammenfassen, ich kann ja noch mal die meta Analogie Ebene
49:57
zusammenfassen, die wir so quasi aufgebaut haben in dieser Folge
50:03
also gehen wir noch mal quasi von.
50:08
Unserem Burgerladen aus ne also die simple Factory ist ich geh
50:12
jetzt hin und bestelle einen einzelnen Burger.
50:14
Ja, also wirklich nur ich bin in einem Laden, es gibt nur diesen
50:17
Laden, es gibt nur einen definierten Cheeseburger und ich
50:20
will n Cheeseburger haben, dann ist klar wie der aussieht und
50:22
ich Krieg den ja das erweitert wenn wir jetzt gesagt haben na
50:27
ja verschiedene Köche gleiche Karte aber unterschiedlicher
50:30
Burger ne also ich kann jetzt bei verschiedenen Köchen.
50:33
Einen Cheeseburger bestellen und der wird halt unterschiedlich
50:35
sein am Ende, weil es ja der unter unterschiedlich zubereitet
50:39
wird, sehr wahrscheinlich, da hatten wir ja die
50:40
Länderbeispiele genannt und da kommt halt die Factory, das
50:43
eigentliche Factory Pattern ins Spiel, dass man sagt, gut, wir
50:45
haben jetzt abstrakten Burger und der wird jetzt in den
50:49
Subklassen definiert Cheeseburger und so sieht er aus
50:53
und jeder implementiert sich seinen Cheeseburger, sozusagen
50:55
ne und dann abhängig davon wo ich bin, kriege ich dann
50:58
dementsprechend den Cheeseburger und die Abstract Factory.
51:03
Die maximale Ausbaustufe, sag ich mal, ist halt das
51:06
Menübeispiel. Wenn ich jetzt n komplettes Menü
51:09
haben möchte, dann krieg ich halt auch entsprechend immer
51:11
passend Beilagen und Getränke beziehungsweise ich kann denn
51:14
nur auswählen, was passend für den Laden dazu ist.
51:17
Ja, also wie sieht das Burger Menü da aus?
51:20
Genau. Und das ganze n bisschen
51:22
technisch. Kannst du es noch so n bisschen
51:23
einordnen wo du was so ungefähr verwenden würdest?
51:27
Zum Beispiel? Wir hatten es ja jetzt auch so
51:29
in der Folge n bisschen angeschnitten.
51:30
Ja, also simple Factory, ne, da hat man hat man eher zum
51:35
Beispiel so n Interface was man verwendet für kleinere Projekte
51:38
vielleicht Tutorials ne wenn man jetzt nicht so viele Varianten
51:41
von Objekten von von von einem Typ hat, beispielsweise das
51:45
Factory Pattern jetzt beispielsweise.
51:48
Wenn man dann mehr Objekte, wenn es komplexer wird, man halt
51:51
mehrere Objekte hat, die vielleicht auch noch in Klassen
51:55
wiederum gegliedert werden können, ne und also wie jetzt
52:00
zum Beispiel halt ne, was du ja auch gerade beschrieben hattest
52:02
mit deinen Beispielen und wenn du jetzt abstract Factory ne
52:08
Abstract factory nimmst, dann bist du halt auf
52:11
unterschiedlichen Objektfamilien unterwegs.
52:16
Dass du halt sagst, okay. Du kannst erstmal über das
52:19
Factory Pattern kannst du dir ein eine bestimmte Familie
52:24
überhaupt holen, dass man da gar nicht irgendwie sich vertun kann
52:28
und dann ein spezifisches Objekt aus dieser Familie, das heißt du
52:32
Filterst im Endeffekt ein bisschen vor, so und ja, dafür
52:40
sind eigentlich die Sachen ganz gut gedacht, wie gesagt, es ist
52:43
ich glaube so ein Abstract Factory.
52:47
Habe ich zum Beispiel selber noch gar nicht verwenden müssen,
52:49
weil es ist auch immer die Frage, wann braucht man das
52:53
wirklich. Es ist, es ist ratsam, so was
52:56
irgendwann mal einfach spaßeshalber zu programmieren,
52:59
um es mal gemacht zu haben, aber das bedeutet noch lange nicht,
53:02
dass es unbedingt wichtig ist, das anzuwenden, ne, aber wenn du
53:05
jetzt zum Beispiel sagst simple Factory und Factory Pattern,
53:08
diese beiden würde ich zum Beispiel schon als sehr
53:11
hochfrequent einordnen und das ist durchaus wirklich wichtig,
53:14
dass man auch dann. Das versteht und das auch
53:17
anwenden. Kann also.
53:19
Die Abstract Factory ist sehr wahrscheinlich oder oftmals
53:23
nicht notwendig selbst zu implementieren, weil man ja auch
53:25
oft auf Frameworks und Libraries zurückgreift, die das unter der
53:29
Haube implementieren. Gerade so in der Cross Plattform
53:31
Welt wird das ja dir quasi genau diese Sachen werden die ja
53:37
abgenommen dann am Ende ne, weil das halt unter der Haube so
53:40
implementiert wurde. Aber das wäre auch so.
53:43
Ich würde gerne noch so ein 2 Tipps oder jeder ein Tipp kann
53:46
man am Ende noch mitgeben so bevor ich die Folge schließe
53:48
sage ich mal, das wäre nämlich auch genau mein Tipp gewesen,
53:51
was du gerade angeschnitten hast.
53:54
Ist liebe Zuhörer, liebe Zuhörer, falls du dich mit dem
53:56
Factory Pattern noch nicht so auseinandergesetzt hast oder
53:59
immer noch ein bisschen struggles, weil du vielleicht
54:00
gerade am Anfang der Softwareentwicklung stehst,
54:03
probiere es aus, nimm dir die Beispiele unserer Analogien wie
54:06
zum Beispiel mcdonalds oder dem Burgerladen allgemein oder die
54:10
Pizzeria oder. Und Programmier damit mal
54:13
einfach n factory pattern, sag dir, ich mach jetzt n simple
54:16
Factory, dann refactor ich das zum Factory Pattern zum Beispiel
54:20
und ich probier auch mal ruhig n Abstract Factory aus, damit ich
54:23
es einfach mal gemacht hab, dann sieht man einfach, welche coole
54:25
Möglichkeit dieses Pattern bildet oder bietet um Code zu
54:29
strukturieren. Ja, auf jeden Fall.
54:32
Und wie gesagt, am besten immer. Kleinen anfangen, sich dann wie
54:36
du auch eigentlich meintest ne du hangelt, man hangelt sich
54:38
einfach von der einen Factory zur anderen durch und ich würde
54:41
auch einfach mal wirklich sagen OK wenn man das gemacht hat und
54:44
diese Factory gebaut hat würde ich noch mal sozusagen daneben
54:48
legen. Das gleiche Beispiel was du
54:50
gebaut hast und keine Factory verwenden um einfach mal genau
54:53
gegenüber zu diesen diese Gegenüberstellung zu haben.
54:56
Wie sieht es denn mit aus und wie sieht es ohne aus und was
54:59
gefällt mir besser und die Antwort liegt nach dieser Folge
55:02
eigentlich auf der Hand. Ja.
55:04
Sehr gut. Ich denke, wir haben es sehr
55:06
umfangreich besprochen, da sieht man mal, dass man zu so einem
55:09
Designpattern echt viel erzählen kann, gerade wenn man damit mal
55:12
so n bisschen Analogien bringt. Aber ganz ehrlich, das hilft
55:16
einfach mega das zu verstehen, das hat mir damals geholfen und
55:18
ich hätte mir gewünscht, dass mir jemand das mal so anhand von
55:21
einfachen Beispielen erklärt und deswegen vielen Dank dafür, Fabi
55:25
ebenso Liebe zur Liebe zur falls dir die Folge gefallen hat oder
55:29
du Anmerkungen hast zu den Pattern oder Fragen, schreib uns
55:33
gerne. Alle Links zu den Plattformen
55:35
oder auch unsere Podcast Mail findest du in den Shownotes.
55:38
Wenn dir der Podcast allgemein gefällt, lass auch gerne ne
55:41
Bewertung da, das hilft uns quasi weiter zu wachsen und noch
55:45
mehr Leuten unseren Content anbieten zu können und damit
55:48
noch mehr Leute davon profitieren können.
55:50
Und ja, ansonsten würde ich sagen, hören wir uns alle beim
55:54
nächsten Mal wieder. Und lasst euch den Burger
55:56
schmecken. Und lasst euch den Burger, ich
55:58
geh jetzt Burger bestellen. Und habt ne gute Zeit bis dahin
56:02
und bis zum nächsten Mal deine Coding Bodys.
56:05
Gemeinsam besser.