1
00:00:03,280 --> 00:00:06,080
Moin zufolge 82 von einfach 
komplex. 

2
00:00:06,080 --> 00:00:08,320
Hier spricht Gerrit und ich hab 
den Burkhard auch da. 

3
00:00:08,320 --> 00:00:11,240
Hallo Burkhard. 
Moin, nicht aus Hamburg mal 

4
00:00:11,360 --> 00:00:13,680
wieder von der Ostsee so n paar 
Folgen hatten wir hier schon mal

5
00:00:13,680 --> 00:00:15,440
glaub ich oder Gerrit. 
Haben wir schon gemacht. 

6
00:00:15,440 --> 00:00:18,760
Ja, und wenn es heute raschelt 
und und rüttelt und knallt am 

7
00:00:18,760 --> 00:00:20,640
Mikrofon, dann liegt das daran, 
weil du es in der Hand. 

8
00:00:20,640 --> 00:00:22,880
Hast genau, ich fühl mich hier 
wieso n wie n Popsänger hier 

9
00:00:22,880 --> 00:00:25,560
gerade Mikro. 
Ich hab nämlich den blöden 

10
00:00:25,560 --> 00:00:28,160
Mikrofonständer vergessen und da
hast du das Ding halt in der 

11
00:00:28,160 --> 00:00:29,760
Hand, ja. 
Nicht so schlimm. 

12
00:00:29,920 --> 00:00:32,479
Thematisch wird es ja relativ 
einfach sein heute für dich, 

13
00:00:32,479 --> 00:00:36,160
hast du gesagt, also OOP Object 
Oriental programming, ich glaube

14
00:00:36,160 --> 00:00:38,640
letzte Woche deine Worte waren, 
das muss eigentlich jeder 

15
00:00:38,640 --> 00:00:41,280
Programmierer und jede 
Programmiererin aus dem Stegreif

16
00:00:41,280 --> 00:00:44,000
einfach mal so drauf haben. 
Stimmt, das hab ich gesagt. 

17
00:00:44,000 --> 00:00:46,000
Ja, das ist so. 
Ja, hier ist auch meine Meinung.

18
00:00:46,000 --> 00:00:48,320
Ja also OP ist glaub ich heute 
noch zentral. 

19
00:00:48,320 --> 00:00:50,800
Ja objektorientiertes 
programmieren ist das was man 

20
00:00:50,800 --> 00:00:53,760
schon drauf haben sollte, ja. 
Erfahren wir in dieser Folge 

21
00:00:53,760 --> 00:00:54,880
warum. 
Aber ich glaub das kann auch 

22
00:00:54,880 --> 00:00:57,600
jeder jeder über gute 
Programmierer kann das aus dem 

23
00:00:57,600 --> 00:01:00,000
Stegreif schießen, so was die 
wichtigsten Konzepte sind und 

24
00:01:00,000 --> 00:01:02,120
so, ja. 
Na ja, trotzdem wertvoll drüber 

25
00:01:02,120 --> 00:01:04,360
zu sprechen, weil wir haben auch
schon, das hab ich jetzt 

26
00:01:04,360 --> 00:01:08,560
irgendwie häufig erwähnt, in 
allen möglichen Folgen OP und 

27
00:01:09,200 --> 00:01:12,320
wir haben das ja auch n bisschen
bei unserem Produkt drinne, die 

28
00:01:12,320 --> 00:01:15,120
Konzepte davon, vielleicht sagst
du dazu auch was, nachher weiß 

29
00:01:15,120 --> 00:01:18,400
ich nicht, auf jeden Fall 
interessiert es mich daher auch 

30
00:01:18,400 --> 00:01:20,640
und ich bin da ja auch schon in 
Berührung gekommen, obwohl ich 

31
00:01:20,640 --> 00:01:22,400
ja. 
Gar nicht Programmierer bin oder

32
00:01:22,400 --> 00:01:25,200
Softwareentwickler? 
Dann lass doch mal loslegen mit 

33
00:01:25,200 --> 00:01:29,400
OOP, Object Oriental Programming
und Du gibst uns wie immer mal n

34
00:01:29,400 --> 00:01:32,880
kleinen Überblick zum Start. 
Was ist das eigentlich und was 

35
00:01:32,880 --> 00:01:37,040
gibt es da noch, vielleicht auch
in Abgrenzung zu was nicht OOP 

36
00:01:37,040 --> 00:01:38,800
ist. 
Ja, genau so würde ich es 

37
00:01:38,800 --> 00:01:40,240
tatsächlich auch anfangen. 
So hab ich es n bisschen. 

38
00:01:40,240 --> 00:01:42,040
Ich hab ja mal wieder n Spicker 
gemacht, das ist immer 

39
00:01:42,040 --> 00:01:44,200
eigentlich ganz cool und der 
Spicker, der ist nie digital bei

40
00:01:44,200 --> 00:01:46,560
mir, ich hab immer richtig so 
hier mit dem Kuli und so, das 

41
00:01:46,560 --> 00:01:48,240
find ich eigentlich gar nicht 
schlecht, aber der Spicker der 

42
00:01:48,240 --> 00:01:49,720
sagt. 
Fangen wir gar nicht bei 

43
00:01:49,720 --> 00:01:51,680
Objektorientiert an. 
Das ist nämlich erst Punkt 3. 

44
00:01:52,320 --> 00:01:55,200
In Punkt 1. 
Fangen wir erst mal anzugucken, 

45
00:01:55,360 --> 00:01:57,680
was gibt es überhaupt, also wo 
will ich überhaupt hin. 

46
00:01:57,680 --> 00:02:00,240
Objektorientiertes Programmieren
ist ja ne Art Quellcode 

47
00:02:00,240 --> 00:02:03,120
aufzuschreiben, das ist es ja, 
und da gibt es halt noch 

48
00:02:03,120 --> 00:02:05,400
verschiedene Arten und ganz am 
Anfang oder die einfachste Art 

49
00:02:05,400 --> 00:02:09,199
ist die imperative Art, so heißt
es ja Punkt 1, Imperativ ja, wir

50
00:02:09,280 --> 00:02:11,039
müssen ja mal kurz einordnen, 
objektorientiertes programmieren

51
00:02:11,039 --> 00:02:14,280
ist halt ne Art des Quellcodes 
aufschreibens hab ich gerade 

52
00:02:14,280 --> 00:02:16,240
schon gesagt und was ist 
Quellcode, es sind einfach die 

53
00:02:16,240 --> 00:02:17,920
Zeilen sind Instruktionen sind 
Programme. 

54
00:02:19,000 --> 00:02:22,280
Produktionen in Programmen ja, 
ich fang mal im Urstand noch mal

55
00:02:22,280 --> 00:02:24,760
ganz kurz an. 
Ich kann natürlich Assembler 

56
00:02:24,760 --> 00:02:27,120
hinschreiben, das ist das das 
Maschinennase, darüber sprechen 

57
00:02:27,120 --> 00:02:30,000
wir nicht, wir sprechen schon 
über Source Code, aber wir 

58
00:02:30,000 --> 00:02:32,440
sprechen auch schon über die 
ersten Programmiersprachen, die 

59
00:02:32,440 --> 00:02:35,360
es so gab, ja also auch so ganz 
weit zurück, ja, in den 

60
00:02:35,360 --> 00:02:37,360
Achtzigern und so weiter ja, 
also wir sprechen von heute, 

61
00:02:37,360 --> 00:02:41,280
gucken wir uns mal an, C und C 
plus Plus und und wie sie alle 

62
00:02:41,280 --> 00:02:43,120
sind, ja. 
So, wenn man jetzt über 

63
00:02:43,120 --> 00:02:45,480
Programmiersprachen nachdenkt 
und überlegt wie, wieso n 

64
00:02:45,480 --> 00:02:47,920
Programm überhaupt läuft, ja 
dann, dann muss man erstmal 

65
00:02:47,920 --> 00:02:51,680
feststellen so n Programm läuft 
im Prinzip erstmal von oben nach

66
00:02:51,680 --> 00:02:53,320
unten. 
Ja ich schreib es halt irgendwie

67
00:02:53,320 --> 00:02:56,600
in den Editor hin, heute sind 
das irgendwie so tolle IDES, die

68
00:02:56,600 --> 00:02:59,480
ganz viel können und jetzt auch 
AI Integration haben und so 

69
00:02:59,480 --> 00:03:02,880
weiter aber am Ende des Tages 
ist eigentlich nur Text der 

70
00:03:02,880 --> 00:03:05,440
Quelltext nämlich den ich in 
einem beliebigen Editor 

71
00:03:05,440 --> 00:03:08,720
aufmachen kann und ich schreib 
in jede Zeile ne Anweisung von 

72
00:03:08,720 --> 00:03:11,600
meinem Programm, ne. 
Und wenn ich erstmal nichts 

73
00:03:11,600 --> 00:03:15,440
Besonderes mache, dann dann 
läuft das Programm von ganz 

74
00:03:15,440 --> 00:03:18,840
oben, von der ersten Zeile durch
immer eine Zeile weiter. 

75
00:03:18,840 --> 00:03:22,160
Ja so, und wenn ich, wenn ich 
mein ganzes Programm, meine 

76
00:03:22,160 --> 00:03:25,440
ganze Logik so aufbaue, dass ich
einfach Zeile für Zeile für 

77
00:03:25,440 --> 00:03:28,720
Zeile durchgehe, dann nennt sich
das Imperativ aufgeschrieben ne,

78
00:03:29,200 --> 00:03:31,120
und da kann ich dann auch gar 
nicht mehr so viel machen, ich 

79
00:03:31,120 --> 00:03:34,520
springe also quasi nicht wild in
diesem in diesem Quelltext hin 

80
00:03:34,520 --> 00:03:36,200
und her, sondern es geht 
tatsächlich Zeile für Zeile 

81
00:03:36,200 --> 00:03:38,480
runter, ich hab so n paar Sachen
wie. 

82
00:03:38,960 --> 00:03:40,640
Konditionen, das kennt, das 
kennen wir ja alle. 

83
00:03:40,640 --> 00:03:42,720
Ja, if than else. 
Also ich schreibe zum Beispiel, 

84
00:03:42,880 --> 00:03:47,040
wenn das und das ist, dann 
machst du die Zeile, Else machst

85
00:03:47,040 --> 00:03:49,840
die andere, das heißt, es kann 
schon mal hüpfen, ja, weil im 

86
00:03:49,840 --> 00:03:52,680
Speicher irgendwas ne Variable 
ist, die dann jetzt quasi nicht 

87
00:03:52,720 --> 00:03:54,520
nicht schwul ist. 
An dem an der Stelle also hüpft 

88
00:03:54,520 --> 00:03:57,840
es quasi weiter, ja oder ich hab
sowas wie schleifen, das gehört 

89
00:03:57,840 --> 00:04:00,240
auch alles zum Imperativen 
programmieren, dass ich sage, 

90
00:04:00,720 --> 00:04:04,200
solange irgendwas noch nicht 
wahr ist, machst du das im Kreis

91
00:04:04,200 --> 00:04:07,440
ja, bis es da ist, ja. 
Oder so n vor Loop. 

92
00:04:07,440 --> 00:04:10,000
Ja, wenn du so n Array 
durchgehst ja, also für alle 

93
00:04:10,000 --> 00:04:13,200
Einträge in diesem Array machst 
du wieder irgendwas und so 

94
00:04:13,200 --> 00:04:16,320
weiter ja und ganz früher gab es
noch so n so n Mittel und so 

95
00:04:16,320 --> 00:04:19,720
N-Weg um im Imperativen 
irgendwie Sachen Anzuspringen, 

96
00:04:19,720 --> 00:04:22,560
das ist ziemlich stark 
verteufelt, heutzutage macht man

97
00:04:22,560 --> 00:04:24,840
gar nicht mehr, es hat sich 
herausgestellt, dass es gar 

98
00:04:24,840 --> 00:04:28,360
keine gute Idee ist für die 
Lesbarkeit des Codes und für die

99
00:04:28,360 --> 00:04:30,440
Wartbarkeit ist das sogenannte 
Go too. 

100
00:04:30,440 --> 00:04:32,080
Ich glaub in irgendeiner Folge 
hatte ich glaub ich auch schon 

101
00:04:32,080 --> 00:04:34,960
mal go too erwähnt, ja. 
Also mit so einem Goto kannst du

102
00:04:34,960 --> 00:04:36,480
halt. 
Das sagst du halt quasi im 

103
00:04:36,480 --> 00:04:39,040
Quelltext. 
So jetzt die Anweisung dieser 

104
00:04:39,040 --> 00:04:42,560
Zeile, heißt halt quasi hüpf an 
ne beliebige andere Zeile. 

105
00:04:42,640 --> 00:04:45,480
Ja du kannst tatsächlich sagen, 
es war noch so, im Basic kannst 

106
00:04:45,480 --> 00:04:48,920
du sagen goto 70 oder 
Irgendsowas und da hast du quasi

107
00:04:48,920 --> 00:04:51,560
die Zeilen auch noch nummeriert 
als Teil des Quelltext ist nicht

108
00:04:51,560 --> 00:04:55,360
als nicht der Editor hat dir das
durchgezählt, sondern Quelltext 

109
00:04:55,360 --> 00:04:57,520
mit Anweisung war halt die 
Zeilennummer ja und hast gesagt 

110
00:04:57,520 --> 00:05:00,120
go to 70. 
Also wenn du eine eine eingefügt

111
00:05:00,120 --> 00:05:02,360
hast, dann musst du alle einmal 
alle alle hochzählen oder wie 

112
00:05:02,360 --> 00:05:04,000
ja. 
Deswegen hat man die 1020 30 

113
00:05:04,000 --> 00:05:05,880
gemacht und wenn du das 
vergessen hattest, dann konntest

114
00:05:05,880 --> 00:05:07,240
du dann noch mal die 31 oder so 
dazwischen quetschen. 

115
00:05:07,240 --> 00:05:10,600
Ja, das war früher, bei mir war 
das alles noch ziemlich 

116
00:05:10,600 --> 00:05:13,400
hardcore, ja, aber das führt 
natürlich dazu kann man sich 

117
00:05:13,400 --> 00:05:14,720
jetzt vorstellen. 
Wenn du jetzt also einfach von 

118
00:05:14,720 --> 00:05:17,680
oben da runter schreibst und 
hast halt quasi nur IF LS und so

119
00:05:17,680 --> 00:05:19,520
n paar Schleifen und so n Switch
Statement oder Irgendsowas und 

120
00:05:19,520 --> 00:05:22,680
deinen Code oder aber großen 
willst relativ viel machen. 

121
00:05:24,160 --> 00:05:28,240
Ja, dann kriegst du n relativ 
großen Klumpen Haufen Codes und 

122
00:05:28,840 --> 00:05:31,200
es wird relativ sehr zügig 
unübersichtlich. 

123
00:05:31,200 --> 00:05:32,640
Ja dann springst du noch von go 
too. 

124
00:05:32,640 --> 00:05:35,040
Du versuchst, du hast ja oft 
hast du ja das Problem, dass du 

125
00:05:35,040 --> 00:05:37,120
noch mal ne Sache noch mal 
machen musst, die du schon 

126
00:05:37,120 --> 00:05:39,840
irgendwo hingetippt hattest. 
Ja, und dann springst du da 

127
00:05:39,840 --> 00:05:41,880
wieder hin mit so einem Go too. 
Dann lässt du das laufen, dann 

128
00:05:41,880 --> 00:05:44,080
springst du wieder zurück und 
sofort und so weiter ja, das 

129
00:05:44,080 --> 00:05:48,040
wird richtig Schlamassel. 
Ja und das nächste Level und das

130
00:05:48,040 --> 00:05:50,720
gibt es auch schon sehr sehr 
lang, das ist das Prozeduale 

131
00:05:50,720 --> 00:05:53,280
programmieren Punkt 2 quasi 
jetzt auf meiner Liste. 

132
00:05:54,000 --> 00:05:56,880
Immer noch vor dem 
objektorientierten ne und was 

133
00:05:56,880 --> 00:05:59,600
hat das Prostituale 
programmieren quasi dem 

134
00:06:00,080 --> 00:06:02,240
operativen Programmieren 
hinzugefügt? 

135
00:06:02,320 --> 00:06:04,840
Das sind die Funktionen, so 
Funktionen haben wir ja auch 

136
00:06:04,840 --> 00:06:07,200
schon tausendmal gesagt, aber 
Funktionen sind halt quasi, sind

137
00:06:07,200 --> 00:06:10,320
halt irgendwie ja das Salz in 
der Suppe von von jedem 

138
00:06:10,320 --> 00:06:12,880
Quelltext erst exakt wichtig 
warum? 

139
00:06:12,880 --> 00:06:16,400
Weil ich weil ich jetzt kann ich
jetzt habe ich die Möglichkeit 

140
00:06:16,400 --> 00:06:19,360
schon mal Quelltext 
hinzuschreiben, den ich 

141
00:06:19,360 --> 00:06:22,720
wiederverwenden kann, erstens. 
Und zweitens ja nicht sofort 

142
00:06:22,720 --> 00:06:28,000
ausgeführt wird, den ich quasi 
aufrufen kann mit einer Zeile 

143
00:06:28,000 --> 00:06:30,160
Code. 
Ja, also ich schreibe schon mal 

144
00:06:30,160 --> 00:06:34,480
im Vorhinein irgendeine Funktion
auf, zum Beispiel Average, mach 

145
00:06:34,480 --> 00:06:37,920
mir nen Mittelwert und wenn ich 
das Hinschreibe ne Funktion, das

146
00:06:37,920 --> 00:06:40,840
haben alle Funktionen gleich, 
dann muss ich sagen, dann muss 

147
00:06:40,840 --> 00:06:44,080
ich definieren mit was ruf ich 
denn die Funktion auf. 

148
00:06:44,080 --> 00:06:47,880
Also ich gebe Parameter über 
variablen Speicher ja wo 

149
00:06:47,880 --> 00:06:49,440
irgendwie schon mal was drin 
stand, ja. 

150
00:06:50,000 --> 00:06:52,560
Also bei einem Mittelwert würde 
man typischerweise nen nen Feld 

151
00:06:52,560 --> 00:06:55,680
oder n array wie man sagt auf 
Englisch von von Zahlen quasi 

152
00:06:55,680 --> 00:06:58,920
mitgeben und die Idee der 
Funktion ist aus diesen Zahlen 

153
00:06:58,920 --> 00:07:01,720
quasi n Mittelwert auszurechnen.
Ne können wir alle, man muss 

154
00:07:01,720 --> 00:07:04,120
also quasi alle zahlen addieren 
und durch die Anzahl der Zahlen 

155
00:07:04,120 --> 00:07:07,240
teilen und das ist jetzt das 
zweite Konzept, dann kommt was 

156
00:07:07,240 --> 00:07:10,920
zurück, der Return wert ja also 
Funktion ich geb was rein und 

157
00:07:10,920 --> 00:07:13,480
ich krieg was zurück das 
passiert aber dass die Funktion 

158
00:07:13,480 --> 00:07:15,600
wird nicht einfach aufgerufen 
sofort wenn das Programm 

159
00:07:15,600 --> 00:07:17,920
losgeht. 
Das ist der Knackpunkt. 

160
00:07:18,160 --> 00:07:21,680
Ich kann diese Funktion schon 
mal irgendwo hinschreiben und 

161
00:07:21,680 --> 00:07:23,480
ich hab auch noch nicht 
definiert, mit was die genau 

162
00:07:23,480 --> 00:07:26,320
aufgerufen werden, das passiert 
nämlich erst zur Ausführungszeit

163
00:07:26,320 --> 00:07:29,520
des Programms, aber jetzt kann 
ich quasi, wenn ich noch mal 

164
00:07:29,520 --> 00:07:32,160
noch mal von top down losgehe, 
ich könnt ja sagen, ich hab n 

165
00:07:32,160 --> 00:07:34,800
Programm, das soll aus den 
Eingaben wenn es n 

166
00:07:34,800 --> 00:07:37,760
konsolenprogramm ist. 
Ich schreib quasi my Program 

167
00:07:37,760 --> 00:07:40,800
oder my averager und dann geb 
ich dahinter einfach Nummern an,

168
00:07:41,200 --> 00:07:44,480
dann läuft das Programm und es 
kommt und wird und printet quasi

169
00:07:44,480 --> 00:07:46,640
zum Schluss einfach den 
Mittelwert auf die Konsole, ja. 

170
00:07:47,520 --> 00:07:50,400
So, dann könnte ich quasi diese 
ganzen Eingaben verarbeiten, die

171
00:07:50,400 --> 00:07:51,920
ich ja vorher noch nicht kenne 
im Programm. 

172
00:07:52,000 --> 00:07:53,720
Als ich den Quelltext 
geschrieben habe, wusste ich ja 

173
00:07:53,720 --> 00:07:55,600
nicht, was derjenige dann da 
eintippt, so, das heißt, ich 

174
00:07:55,600 --> 00:07:58,440
nehme die alle auf Les, die 
quasi aus der Kommandozeile, das

175
00:07:58,440 --> 00:08:01,680
kann man machen und dann rufe 
ich dieses diese Funktion 

176
00:08:02,000 --> 00:08:05,920
Average auf, an einer Stelle 
code, dann springt es dahin, der

177
00:08:05,920 --> 00:08:09,440
Programmfluss springt dann in 
die Funktion, ruft die auf, dann

178
00:08:09,440 --> 00:08:12,880
geht der Programmfluss und das 
ist wichtig wieder Zeile von 

179
00:08:12,880 --> 00:08:15,440
oben nach unten in der Funktion,
denn die Funktion ist ja auch 

180
00:08:15,440 --> 00:08:18,480
implementiert. 
Mit mit dem, was sie halt tun 

181
00:08:18,480 --> 00:08:19,840
soll. 
Ja, die hat also quasi so ne 

182
00:08:19,840 --> 00:08:22,760
Funktionsdeklaration, nennt man 
das oben den Header, das ist 

183
00:08:22,760 --> 00:08:24,640
sehr unterschiedlich, da sag ich
gleich noch was zu zu den 

184
00:08:24,640 --> 00:08:27,040
verschiedenen 
Programmiersprachen und dann 

185
00:08:27,040 --> 00:08:29,840
kommt der von quasi der Buddy so
man sagt mal, also quasi der 

186
00:08:29,840 --> 00:08:31,800
Inhalt der Funktion und das 
letzte Statement ist 

187
00:08:31,800 --> 00:08:35,280
typischerweise Return und mit 
dem Return wird quasi wieder 

188
00:08:35,360 --> 00:08:38,240
wieder n Wert zurückgegeben aus 
der Funktion und mit dem Return.

189
00:08:38,240 --> 00:08:42,360
Das heißt deswegen auch Return 
also Return zum Ursprungspunkt 

190
00:08:42,360 --> 00:08:43,919
wo du hergekommen bist zurück 
ja. 

191
00:08:44,760 --> 00:08:47,160
Das heißt, irgendwo im Code ruf 
ich ne Funktion auf, dann 

192
00:08:47,160 --> 00:08:49,920
passiert das und dann springe 
ich zurück mit dem Return und 

193
00:08:49,920 --> 00:08:52,480
geb aber auch den Wert zurück, 
den ich dann weiter benutzen 

194
00:08:52,480 --> 00:08:55,240
kann. 
Kurze Frage, weil du hast das 

195
00:08:55,240 --> 00:08:57,920
jetzt gerade so betont, dass da 
jemand also was eintippt, zum 

196
00:08:57,920 --> 00:09:02,080
Beispiel diese Nummern, die dann
also den My averager und dann 

197
00:09:02,080 --> 00:09:04,160
die Nummern und dann wird 
irgendwo die Funktion mit n 

198
00:09:04,160 --> 00:09:06,560
Average aufgerufen. 
Nimmt dann diese Nummern macht n

199
00:09:06,560 --> 00:09:10,360
Average, war das bei der 
Imperativen Software oder Art 

200
00:09:10,360 --> 00:09:12,880
und Weise kurz zu schreiben 
nicht möglich. 

201
00:09:13,320 --> 00:09:15,840
Von außen Input Reinzugeben, 
dann in das Programm. 

202
00:09:16,000 --> 00:09:18,920
Klang gerade so n bisschen so, 
weil du so betont hast, nee nee,

203
00:09:18,920 --> 00:09:20,880
das verging auch beim 
Imperativen kannst du genauso 

204
00:09:20,880 --> 00:09:24,400
machen, bloß da hättest du dann 
quasi sagen müssen der Reihe 

205
00:09:24,400 --> 00:09:26,280
nach. 
Ja jetzt lese ich Argument 1 von

206
00:09:26,280 --> 00:09:28,920
der Konsole jetzt 234 bis ich 
keins mehr finde, das hättest du

207
00:09:28,920 --> 00:09:31,720
auch machen können und jetzt 
würdest du aber quasi sofort im 

208
00:09:31,720 --> 00:09:34,960
im weiteren Fluss des Programmes
dann sagen müssen, so und jetzt 

209
00:09:34,960 --> 00:09:37,440
in der nächsten Zeile rechne ich
die zusammen ja was ich gefunden

210
00:09:37,440 --> 00:09:40,400
hab ja irgendwie a 1 plus a 2 
plus a 3 plus a 4. 

211
00:09:41,440 --> 00:09:43,440
Und weil sich das noch mal ne 
Variablen zu die irgendwie die 

212
00:09:43,440 --> 00:09:45,960
Summe ist, ja könnt zum Beispiel
sagen, Summ ist gleich a 1 plus 

213
00:09:45,960 --> 00:09:49,000
a 2 plus a 3 plus a 4, die ich 
vorher gelesen hab, aus der aber

214
00:09:49,000 --> 00:09:51,200
alles der Reihe nach ja so und 
dann will ich noch mal sagen 

215
00:09:51,200 --> 00:09:54,080
Summ, geteilt durch die Anzahl 
von denen und dann will ich es 

216
00:09:54,080 --> 00:09:57,520
ausprinten und fertig, ja dann 
hätte ich das aber alles quasi 

217
00:09:57,520 --> 00:10:00,080
unstrukturiert Zeile für Zeile 
runtergeschrieben. 

218
00:10:00,080 --> 00:10:04,240
Ja, während das prozedurale 
Programm auch die Parameter von 

219
00:10:04,240 --> 00:10:06,720
der Konsole liest und wenn sie 
es aber hat, dann würde sie 

220
00:10:06,720 --> 00:10:10,240
sagen Ruf auf ja average 
Funktion. 

221
00:10:10,600 --> 00:10:12,640
Also es wird richtig aufgerufen,
dann kann man dann, das kann man

222
00:10:12,640 --> 00:10:16,080
quasi per Name, die Funktionen 
haben immer nen Namen im 

223
00:10:16,080 --> 00:10:18,440
Quelltext und dann ruf ich 
einfach mit dem Namen, der 

224
00:10:18,440 --> 00:10:21,200
Funktion und den Parametern, die
übergebe ich das auf und dann 

225
00:10:21,200 --> 00:10:24,400
kann ich quasi in einer Zeile 
code kann ich das Everage 

226
00:10:24,400 --> 00:10:27,200
berechnen lassen ja, also in der
in der ich die gerade lese, ja 

227
00:10:27,200 --> 00:10:29,520
und irgendwo in einem anderen 
Pfeil oder auch in dem gleichen 

228
00:10:29,520 --> 00:10:32,560
Pfeil, aber an einer anderen 
Stelle sauber getrennt, optisch 

229
00:10:32,560 --> 00:10:36,080
auch visuell ne für den 
Entwickler steht diese Funktion 

230
00:10:36,080 --> 00:10:39,120
oben ja so, dass das nicht 
einfach so n Haufen. 

231
00:10:39,600 --> 00:10:42,160
Quelltext ist ja, man hat halt 
festgestellt und es ist auch 

232
00:10:42,160 --> 00:10:44,600
heute noch so. 
Wenn du zu viele Zeilen Code, 

233
00:10:44,600 --> 00:10:49,280
die irgendwas machen tatsächlich
untereinander schreibst, ja dann

234
00:10:49,280 --> 00:10:50,960
dann wird das ist das 
menschliche Hirn einfach 

235
00:10:50,960 --> 00:10:53,280
überfordert, das einfach 
wahrzunehmen, was da passiert. 

236
00:10:53,280 --> 00:10:58,000
Ja, also man sagt ja sogar so, 
Funktionen sollen im Schnitt so 

237
00:10:58,000 --> 00:11:01,720
zwischen 5 und 10 Zeilen Code 
nur haben wieder die sie tun, 

238
00:11:01,720 --> 00:11:03,920
ne. 
Aber dann bekommt halt dieser 

239
00:11:03,920 --> 00:11:06,040
dieser Block Funktion, der 
bekommt halt einen kleinen 

240
00:11:06,040 --> 00:11:07,160
Namen. 
Du machst das ganz ganz 

241
00:11:07,160 --> 00:11:09,520
kleinteilig. 
Ja und du kannst ja in Funktion 

242
00:11:09,520 --> 00:11:11,760
auch wieder Funktionen aufrufen 
und so weiter das kannst du dann

243
00:11:11,760 --> 00:11:14,760
verschachteln ja, aber du teilst
quasi die Logik in viele kleine 

244
00:11:14,760 --> 00:11:17,880
Stückchen, auf die man gut 
verdauen kann, auch so vom Lesen

245
00:11:17,880 --> 00:11:20,880
her ne und vom Verstehen her und
vom Warten auch her. 

246
00:11:20,880 --> 00:11:23,240
Ja du kannst das gehört ja zur 
Testbarkeit dann auch dazu, 

247
00:11:23,240 --> 00:11:26,000
kannst du später komme ich viel 
später erst zu, aber du kannst 

248
00:11:26,000 --> 00:11:28,600
dann quasi Funktionen ja auch 
einzeln testen und gucken ob die

249
00:11:28,600 --> 00:11:30,520
funktionieren für die 
verschiedenen Werte die sie so 

250
00:11:30,520 --> 00:11:32,800
haben ne. 
Und in der Praxis wird das so 

251
00:11:32,800 --> 00:11:36,280
befolgt, also dass man wirklich 
Funktionen so unterbricht und 

252
00:11:36,280 --> 00:11:38,880
Splittet, dass sie immer nur 
ganz, ganz kleine Blöcke von 5 

253
00:11:38,880 --> 00:11:41,920
bis 10 Zeilen sind und ich mein 
es, es klingt ja erstmal 

254
00:11:41,920 --> 00:11:45,280
aufwendiger manchmal dann, wenn 
jetzt nur nur ne ne Funktion 

255
00:11:45,280 --> 00:11:49,480
aufbricht, um des kleinermachen 
willens quasi, klingt aufwendig,

256
00:11:49,480 --> 00:11:52,320
ja. 
Genau das ist also das ist NNN 

257
00:11:52,320 --> 00:11:54,000
schwingendes Thema unserer 
ganzen Folge. 

258
00:11:54,000 --> 00:11:57,200
Hier ist es ist das Engineering 
und das over Engineering, ja. 

259
00:11:57,800 --> 00:12:00,560
Es ist wie alles im Leben. 
Ja, du kannst es übertreiben, 

260
00:12:00,800 --> 00:12:03,760
dann wird es, dann ist es over 
engineered, dann hast du es zu 

261
00:12:03,760 --> 00:12:06,680
klein geteilt. 
Ich muss aber sagen im echten 

262
00:12:06,680 --> 00:12:08,960
Leben, es ist schon so, es gibt 
da auch viele Bücher dazu, 

263
00:12:08,960 --> 00:12:11,160
tatsächlich sind die sehr kurz, 
ja, also wenn du n guter 

264
00:12:11,160 --> 00:12:13,920
Entwickler bist, hältst du die 
sehr kurz, ja und das geht auch 

265
00:12:14,240 --> 00:12:17,520
und so n so n Daumenriegel von 
mir ist so n bisschen macht das 

266
00:12:17,520 --> 00:12:20,280
in ne Funktion was du das erste 
Mal zweimal benutzt weil wir 

267
00:12:20,280 --> 00:12:22,640
haben das große Konzept Don't 
repeat yourself. 

268
00:12:23,440 --> 00:12:25,680
Und das gilt, wenn du 
Sourcecoach schreibst. 

269
00:12:25,680 --> 00:12:27,520
Also wenn du den Quelltext 
schreibst, schon sehr sehr 

270
00:12:27,520 --> 00:12:30,480
stark. 
Wenn du zweimal exakt gleichen 

271
00:12:30,480 --> 00:12:33,200
Teilen Code schreibst, an 
verschiedenen Stellen in deinem 

272
00:12:33,200 --> 00:12:36,480
Quelltext, dann ist es schon n 
Zeichen dafür, dass das in 

273
00:12:36,480 --> 00:12:39,520
Funktion muss. 
Ja, weil dann rufst du einfach 

274
00:12:39,520 --> 00:12:42,560
lieber zweimal diese Funktion 
auf, die sehr kurz sein kann, 

275
00:12:43,040 --> 00:12:45,280
als dass du zweimal an 
verschiedenen Stellen das 

276
00:12:45,280 --> 00:12:46,960
Gleiche machst. 
Ja, was du vergessen hast 

277
00:12:46,960 --> 00:12:49,120
später, was du dann einmal fix 
und das andere nicht und so 

278
00:12:49,120 --> 00:12:51,680
weiter also. 
Es tut nicht weh. 

279
00:12:51,680 --> 00:12:54,600
Funktionsaufrufe sind auch in 
den Programmiersprachen so 

280
00:12:54,600 --> 00:12:57,360
unglaublich schnell, das tut 
auch keiner Performance weh. 

281
00:12:57,360 --> 00:12:59,280
Ja, also es macht überhaupt 
keinen Unterschied mehr, also 

282
00:12:59,520 --> 00:13:01,840
die Empfehlung ist schon alles 
in viele kleine Funktionen zu 

283
00:13:01,840 --> 00:13:05,280
schreiben um die aufzurufen. 
Eigentlich ist so ein Quelltext 

284
00:13:05,280 --> 00:13:09,200
voll von vielen, vielen, vielen 
vielen Funktionen ne und dann 

285
00:13:09,200 --> 00:13:12,280
gibt es so einen Code der sich 
durchzieht, der quasi den roten 

286
00:13:12,280 --> 00:13:14,800
Faden durch die Anwendung findet
und dann immer wieder Funktionen

287
00:13:14,800 --> 00:13:18,160
aufruft. 
Gut, dann noch Zwischenfragen 

288
00:13:18,160 --> 00:13:19,800
gestellt zu. 
Finde ich alles gut. 

289
00:13:19,840 --> 00:13:22,240
Ne, das sind ja wenn wenn man 
wenn man halt nicht so viel 

290
00:13:22,240 --> 00:13:24,480
Source Code schon gelesen hat, 
dann ist es ja irgendwie auch, 

291
00:13:24,480 --> 00:13:27,600
das ist total schwierig das auch
mal zu erzählen, also aber man 

292
00:13:27,600 --> 00:13:30,000
kann ja Python Source Code mal 
so n bisschen lesen das man kann

293
00:13:30,000 --> 00:13:32,280
sich auch mit der mit KI mal n 
bisschen Python Code zeigen 

294
00:13:32,280 --> 00:13:35,440
lassen und so weiter ich hab mal
rausgeguckt spannend wird diese 

295
00:13:35,440 --> 00:13:38,800
Folge schon mal geguckt was so 
wie man so die Funktionen 

296
00:13:38,800 --> 00:13:41,680
deklariert in den verschiedenen 
Programmiersprachen, also wie 

297
00:13:41,680 --> 00:13:44,760
das heißt quasi ja tatsächlich 
ist, nämlich so das heißt es ist

298
00:13:44,760 --> 00:13:47,160
immer Englisch. 
Also auf dem javascript, was wir

299
00:13:47,160 --> 00:13:49,440
hier viel benutzen im Note GS, 
da heißt es tatsächlich function

300
00:13:49,440 --> 00:13:51,680
ne, da schreibst du hin wenn du 
ne Funktion definieren willst, 

301
00:13:51,680 --> 00:13:54,800
dass das Keyword das sogenannte 
Programmierkeyword function, 

302
00:13:55,120 --> 00:13:57,760
damit das mit der Interpreta der
da später dann irgendwie 

303
00:13:58,160 --> 00:14:00,760
interpretiert quasi deinen Code,
der weiß was los ist. 

304
00:14:00,760 --> 00:14:03,760
Ja, und das ist auch so in PAP, 
da heißt es function ja in der 

305
00:14:03,760 --> 00:14:05,760
Programmiersprache go heißt es 
noch Funk. 

306
00:14:06,680 --> 00:14:09,200
Haben sie abgekürzt? 
Ja, und in zum Beispiel in 

307
00:14:09,200 --> 00:14:13,000
Kotlin, Kotlin ist ist so ne 
Hochsprache für Android, also 

308
00:14:13,000 --> 00:14:15,280
wenn du nicht das nicht in Java 
hinschreiben willst, sondern in 

309
00:14:15,280 --> 00:14:17,680
so einer Art, so einer 
einfacheren Sprache, da ist es 

310
00:14:17,680 --> 00:14:22,240
nur noch Fun, also Fun abgekürzt
und am kürzesten ist Rust. 

311
00:14:22,240 --> 00:14:26,200
Da haben Sie es nur noch FN 
genannt, so ne Funktion und ganz

312
00:14:26,200 --> 00:14:29,760
bekannt ist und ganz andere 
Namen hat es in Python, was 

313
00:14:29,760 --> 00:14:32,400
viele Leute hier kennen und auch
in Ruby heißt es def. 

314
00:14:33,200 --> 00:14:36,320
So das sind so die Funktions 
Funktionskeywörter ja. 

315
00:14:36,720 --> 00:14:39,760
In anderen Sprachen, die die 
sehr stark objektorientiert 

316
00:14:39,760 --> 00:14:40,880
sind, da kommen wir jetzt gleich
zu. 

317
00:14:40,880 --> 00:14:42,800
Dann haben die Funktionen gar 
keinen eigenen Namen mehr 

318
00:14:42,800 --> 00:14:44,960
Funktion, das ist einfach, da 
schreibst du nur noch den 

319
00:14:44,960 --> 00:14:47,440
Funktionsnamen hin und die 
entsprechende Syntax und dann 

320
00:14:47,440 --> 00:14:50,000
weißt schon, der weißt schon, 
der Compiler, in dem Fall. 

321
00:14:50,000 --> 00:14:52,320
Typischerweise ist es dann 
kompiliert hier so wie in zum 

322
00:14:52,320 --> 00:14:54,920
Beispiel in C plus Plus und 
Java, da schreibst du nur noch 

323
00:14:54,920 --> 00:14:57,720
den Namen quasi hin und den den 
Returnwert erst und dann den 

324
00:14:57,720 --> 00:15:00,160
Namen und dann die 
Eingabeparameter, dann paar 

325
00:15:00,160 --> 00:15:02,640
Klammern und so weiter und 
sofort da ist das so festgelegt.

326
00:15:03,440 --> 00:15:05,680
So liebe Leute hier nur ein 
kurzer Hinweis. 

327
00:15:05,760 --> 00:15:08,600
Wir sind wieder auf Messen und 
Konferenzen unterwegs und 

328
00:15:08,600 --> 00:15:12,400
möchten euch dazu einladen. 
Und zwar sind wir am 14. 

329
00:15:12,400 --> 00:15:14,720
Und 15. 
Mai auf der Hausmesse der Firma 

330
00:15:14,720 --> 00:15:17,200
Hedelius. 
Hedelius ist Kunde von uns und 

331
00:15:17,200 --> 00:15:20,440
ein Hersteller von CNC 
Bearbeitungszentren, dort gibt 

332
00:15:20,440 --> 00:15:22,640
es ja viele viele 
Bearbeitungszentren und 

333
00:15:22,640 --> 00:15:26,160
Automatisierer und Software zu 
sehen, dort wird Burkhard sein. 

334
00:15:26,480 --> 00:15:31,040
Ich bin zeitgleich in Barcelona 
auf der IOT Solutions World 

335
00:15:31,040 --> 00:15:32,880
Congress. 
Das findet vom 13. 

336
00:15:32,880 --> 00:15:34,320
Bis zum 15. 
Mai statt. 

337
00:15:34,320 --> 00:15:37,040
Dort haben wir natürlich auch 
Freitickets sowie ein paar 

338
00:15:37,040 --> 00:15:41,200
wenige Full Access Tickets, das 
heißt auch inklusive der 

339
00:15:41,280 --> 00:15:43,840
Konferenz, die dort parallel 
stattfindet. 

340
00:15:43,920 --> 00:15:47,040
Falls du Interesse an einem 
solchen Full Access Ticket hast,

341
00:15:47,040 --> 00:15:50,160
schreib uns doch ne kurze e Mail
an podcast@heißenweb.com. 

342
00:15:50,400 --> 00:15:53,920
Ihr findet Informationen zu Herr
Delios Hausmesse und zum IOT 

343
00:15:53,920 --> 00:15:57,200
Solutions World Congress im Link
Tree, in unseren Shownotes und 

344
00:15:57,200 --> 00:15:59,280
wir würden uns freuen, wenn wir 
euch dort treffen. 

345
00:15:59,360 --> 00:16:03,600
Hinweisende gut also jetzt 
hatten wir Imperativ, ist quasi 

346
00:16:03,600 --> 00:16:07,840
einfach Top Down Runterschreiben
von Anweisungen führt zu 

347
00:16:07,840 --> 00:16:10,560
unleserlichen großen 
Spaghettihaufen. 

348
00:16:11,120 --> 00:16:15,400
Prozedural ist zum Beispiel also
ich sag mal was ANSI c, also die

349
00:16:15,400 --> 00:16:19,520
alte gute alte C Sprache, die es
ja auch noch überall gibt. 

350
00:16:20,240 --> 00:16:21,840
Sag ich mal. 
Ist ja nicht weg, wird noch 

351
00:16:21,840 --> 00:16:25,000
genutzt in der maschinennahen 
Programmierung oder auch wenn 

352
00:16:25,000 --> 00:16:26,840
man quasi neue 
Programmiersprachen programmiert

353
00:16:26,840 --> 00:16:30,400
hat, sind die auch gern mal in C
geschrieben hat als als 

354
00:16:30,400 --> 00:16:33,520
strukturierendes Konzept auch 
nur dieses Prozedurale das 

355
00:16:33,520 --> 00:16:38,160
Funktionskonzept C hat nicht die
Idee von Objekten und Klassen. 

356
00:16:38,160 --> 00:16:43,720
Ja da kommen wir jetzt zu, das 
ist aufgekommen im Jahr 67 1967,

357
00:16:43,720 --> 00:16:46,560
da gab es mal simular hab ich 
nie programmiert, weiß nicht wie

358
00:16:46,560 --> 00:16:49,200
das aussieht. 
Das war aber so und das war, 

359
00:16:49,200 --> 00:16:51,600
glaube ich, die die 
Programmiersprache simula war 

360
00:16:51,600 --> 00:16:54,400
eigentlich eher so zum 
Trainieren, zum zum 

361
00:16:54,400 --> 00:16:56,520
beispielhaften, zum Lernen. 
Ich glaube, das war gar nicht so

362
00:16:56,520 --> 00:16:58,680
ernsthaft genommen, dass es 
irgendwie seriöse Anwendungen da

363
00:16:58,680 --> 00:17:01,840
rauskommen sollten, kamen sie 
dann aber später auch noch, war 

364
00:17:01,840 --> 00:17:04,880
so der Vorreiter und hat im 
Prinzip dieses Konzept das 

365
00:17:04,880 --> 00:17:09,040
allererste Mal realisiert, 
nämlich der Klassen und der 

366
00:17:09,040 --> 00:17:13,839
Objekte, was sind jetzt Klassen 
und Objekte, im Prinzip ist das 

367
00:17:14,480 --> 00:17:16,720
also, Klassen und Objekte sind 
erstmal. 

368
00:17:17,119 --> 00:17:19,800
Nur was für Entwickler? 
Ja, also man muss sich erst mal 

369
00:17:19,800 --> 00:17:23,040
fragen, was ist überhaupt Object
Orient Programming für wen hat 

370
00:17:23,040 --> 00:17:24,480
denn das jetzt hier einen 
Mehrwert? 

371
00:17:24,480 --> 00:17:27,839
Ja und alles dieses ganze Gedöns
was wir heute besprechen, 

372
00:17:27,839 --> 00:17:30,960
Imperativ, prozedural, 
Objektorientiert der Mehrwert, 

373
00:17:31,120 --> 00:17:36,240
der liegt nur für den 
Entwickler, das sind Entwickler 

374
00:17:36,320 --> 00:17:40,000
Patterns, das sind Ideen wie ich
schaffe wenn die Anwendung immer

375
00:17:40,000 --> 00:17:42,440
größer werden, wir haben ja 
riesige komplexe Software 

376
00:17:42,440 --> 00:17:47,440
mittlerweile wie schaffe ich es?
Den Kram als Entwickler oder 

377
00:17:47,440 --> 00:17:50,120
sogar als Team von Entwicklern 
irgendwie zu warten und da 

378
00:17:50,120 --> 00:17:53,240
durchzusteigen, wenn das groß 
wird, ohne dass ich da völlig 

379
00:17:53,240 --> 00:17:57,360
überfordert bin, denn am Ende 
ist so ein Programm, am Ende 

380
00:17:57,360 --> 00:18:00,360
macht, das Macht immer so ein so
ein Interpreter oder so ein 

381
00:18:00,360 --> 00:18:02,800
Compiler, im Prinzip zieht er 
das glatt und führt eigentlich 

382
00:18:02,800 --> 00:18:05,280
den Kram von oben nach unten aus
und setzt das so zusammen. 

383
00:18:05,840 --> 00:18:08,240
Also der Quelltext hat nichts 
damit zu tun, wie das Programm 

384
00:18:08,240 --> 00:18:10,400
im Maschinencode später 
ausgeführt wird, das ist nun mal

385
00:18:10,400 --> 00:18:13,760
ein ganz anderes Level. 
Ja, verstehe, darauf war das 

386
00:18:13,760 --> 00:18:15,440
jetzt bezogen mit wo das jetzt n
Vorteil hat. 

387
00:18:15,440 --> 00:18:18,480
Ja, aber grundsätzlich ist es ja
in erster Instanz jetzt n 

388
00:18:18,480 --> 00:18:22,400
Entwickler und hinten raus haben
ja viele Leute was davon wenn 

389
00:18:22,400 --> 00:18:26,160
jetzt Entwickler schneller ist 
einfacher Code warten kann, 

390
00:18:26,480 --> 00:18:29,040
Fehler vielleicht schneller 
wiederfindet et cetera ne das 

391
00:18:29,040 --> 00:18:31,600
ist spart Kosten so. 
Das ist klar. 

392
00:18:31,600 --> 00:18:33,960
Aber ich meine nur, dass die 
divisability, sag ich mal also 

393
00:18:33,960 --> 00:18:36,760
nen nen Anwender von der 
Software kann ja nicht wissen, 

394
00:18:36,760 --> 00:18:38,800
ob das mal irgendwie 
objektorientiert programmiert 

395
00:18:38,800 --> 00:18:41,440
war, was da läuft, oder? 
Auf welche Art und weise ich 

396
00:18:41,440 --> 00:18:45,160
meine jetzt quasi ne, also für 
wen, für wen ist dieses Pattern 

397
00:18:45,160 --> 00:18:47,520
überhaupt gedacht? 
Du kannst also alles auf alle 

398
00:18:47,520 --> 00:18:50,240
Arten irgendwie umsetzen und 
wenn man es jetzt benutzt als 

399
00:18:50,240 --> 00:18:52,000
Anwender, merkt man davon gar 
nichts. 

400
00:18:52,080 --> 00:18:55,560
Genau das ist, was ich sagen 
wollte, ja perfekt, genau so. 

401
00:18:55,560 --> 00:18:57,480
Und was ist jetzt, was ist jetzt
objektorientiert? 

402
00:18:57,480 --> 00:19:00,480
Ja, also man hat jetzt im 
Prinzip und er findet noch mehr 

403
00:19:00,720 --> 00:19:04,560
Patterns außer diese Funktion 
die ich gerade erklärt hat um 

404
00:19:04,560 --> 00:19:07,360
Code noch besser intern zu 
strukturieren, ne. 

405
00:19:08,840 --> 00:19:11,200
Und da hat man sich jetzt halt 
das objektorientierte angeguckt 

406
00:19:11,200 --> 00:19:15,440
und es fügt der normalen 
Funktion ja eigentlich nur 2 

407
00:19:15,440 --> 00:19:20,360
Konzepte zu, nämlich das Konzept
einer Klasse und eine Klasse ist

408
00:19:20,360 --> 00:19:23,200
quasi etwas mehr als eine 
Funktion. 

409
00:19:23,200 --> 00:19:26,840
Ist eine Blau, also eine Klasse,
kann Funktion schon beinhalten, 

410
00:19:26,840 --> 00:19:32,000
ist ein Beutel für Funktion und 
für Daten und diese Klassen. 

411
00:19:32,800 --> 00:19:35,760
Aus denen kann ich quasi zur 
Laufzeit dann Instanzen machen. 

412
00:19:35,760 --> 00:19:38,080
Objekte ja, deswegen heißt es 
objektorientierte 

413
00:19:38,080 --> 00:19:41,040
Programmierung. 
Ja, also das ist die Idee, ja, 

414
00:19:42,000 --> 00:19:45,080
damit kann ich dann quasi noch 
besser strukturieren, ja, weil 

415
00:19:45,080 --> 00:19:47,720
man hat festgestellt, dass ich, 
wenn ich zum Beispiel Funktion 

416
00:19:47,720 --> 00:19:49,520
hab, ich hab es jetzt gerade 
gerade genannt, zum Beispiel 

417
00:19:49,520 --> 00:19:52,320
Average, hatte ich gesagt, ja, 
jetzt könnte ich zum Beispiel ne

418
00:19:52,320 --> 00:19:55,440
Funktion haben, die heißt 
irgendwie running Average, ja, 

419
00:19:55,440 --> 00:19:57,720
weil ich jetzt zum Beispiel ne 
neue ich hab jetzt zum Beispiel 

420
00:19:57,720 --> 00:20:01,320
neue Anforderungen, dass meine. 
Meine Daten, die ich zum Average

421
00:20:01,320 --> 00:20:03,680
bilden will, da kommen immer 
neue Datenpunkte dazu. 

422
00:20:04,320 --> 00:20:06,720
So ein bisschen wie beim wie 
beim Auto oder irgend so was du 

423
00:20:06,720 --> 00:20:09,320
fährst ne und dann kriegst du so
ein Durchschnittswert zum zum 

424
00:20:09,320 --> 00:20:12,960
Benzinverbrauch zum Beispiel und
der der wird dann quasi immer 

425
00:20:12,960 --> 00:20:16,840
akkurater, je länger du fährst, 
ja oder hast dann noch andere 

426
00:20:16,840 --> 00:20:18,840
statistische Auswertung. 
Ja, was ist denn mit meinen 

427
00:20:18,840 --> 00:20:20,880
ganzen Datenpunkten, jetzt 
machst du mehr Statistik, ja was

428
00:20:20,880 --> 00:20:23,040
ist denn mein Minen ne man 
irgendwie haben wir ja gerade 

429
00:20:23,040 --> 00:20:24,840
den Minen, ist ja der Dawage, 
aber was ist denn zum Beispiel 

430
00:20:24,840 --> 00:20:27,040
meine Standardabweichung? 
Ja, was war denn der größte Wert

431
00:20:27,040 --> 00:20:28,720
und der kleinste Wert und so 
weiter. 

432
00:20:29,520 --> 00:20:31,760
Dann schreibst du dafür alles 
Funktionen, stellst aber fest 

433
00:20:31,760 --> 00:20:35,320
verblickte Kiste, die gehören 
irgendwie alle zusammen und die 

434
00:20:35,320 --> 00:20:37,200
haben ja auch die gleiche 
Datengrundlage. 

435
00:20:37,200 --> 00:20:38,600
Ja, die rechnen ja auf den 
gleichen Daten. 

436
00:20:38,600 --> 00:20:41,520
Ne, jetzt kannst du das 
natürlich funktional ausdrücken,

437
00:20:41,520 --> 00:20:43,040
dann kriegen die halt immer 
wieder, da hast du immer wieder 

438
00:20:43,040 --> 00:20:44,960
Funktionen, die kriegen immer 
wieder nen Array von diesen 

439
00:20:44,960 --> 00:20:47,200
ganzen Daten ja und brauchen 
dann immer noch n paar andere 

440
00:20:47,200 --> 00:20:51,280
Seitenparameter aber irgendwie 
stehen sie also quasi mit ganz 

441
00:20:51,280 --> 00:20:53,240
anderen Funktionen die man nicht
zu tun haben ja auf gleicher 

442
00:20:53,240 --> 00:20:56,400
Hierarchieebene ja. 
Und jetzt, im objektorientierten

443
00:20:56,400 --> 00:20:59,160
Programmieren sagt man so, OK, 
nee, pass mal auf die, ich fasse

444
00:20:59,160 --> 00:21:01,680
noch mal n hab noch n 
abstraktionslevel mehr wo ich 

445
00:21:01,680 --> 00:21:03,400
die zusammenfassen kann. 
Ich könnte jetzt zum Beispiel 

446
00:21:03,400 --> 00:21:07,160
sagen, ich hab ne Klasse, die 
nenne ich statistics so und in 

447
00:21:07,160 --> 00:21:10,160
der Statistics klasse pack ich 
meine ganzen statistischen 

448
00:21:10,160 --> 00:21:13,920
Funktionen zusammen, die ich so 
brauche, ja nämlich Compute 

449
00:21:13,920 --> 00:21:18,000
Average, compute running average
oder moving average get mean 

450
00:21:18,000 --> 00:21:20,200
get. 
Get min Max, Standard, 

451
00:21:20,200 --> 00:21:22,440
Navigation und so weiter und 
kann ich diese ganze, dann guck 

452
00:21:22,440 --> 00:21:25,320
ich mir einmal Statistik an. 
Ja hab das gelernt und 

453
00:21:25,320 --> 00:21:28,400
Programmier die ganzen 
Funktionen quasi in so eine 

454
00:21:28,400 --> 00:21:33,200
Klasse Statistics und kann das 
dann quasi als als 

455
00:21:33,520 --> 00:21:34,920
zusammenhängender Haufen 
benutzen. 

456
00:21:34,920 --> 00:21:38,400
Ne und natürlich noch n bisschen
mehr dazu erzähl ich gleich noch

457
00:21:38,400 --> 00:21:40,560
mal was. 
Aber das musst du jetzt noch mal

458
00:21:40,560 --> 00:21:41,840
genau sagen. 
OK, jetzt kannst du das als 

459
00:21:41,840 --> 00:21:44,880
zusammenhängenden Haufen 
benutzen, da schließt sich mir 

460
00:21:44,880 --> 00:21:47,360
der Vorteil noch nicht, sagen 
wir es mal so. 

461
00:21:48,000 --> 00:21:50,160
Das das musst du noch n bisschen
genauer erklären glaub ich, dass

462
00:21:50,160 --> 00:21:52,160
man das als Nichtentwickler auch
versteht. 

463
00:21:52,160 --> 00:21:54,640
Warum das jetzt n Vorteil sein 
könnte oder ist. 

464
00:21:55,440 --> 00:21:57,920
Ja, ja genau, also ich, ich 
erzähl es erstmal so ganz grob 

465
00:21:58,240 --> 00:22:02,240
und ich glaube da kommen wir auf
die auf die 4 Themen, die ja man

466
00:22:02,240 --> 00:22:05,440
sagt auch die 4 Grundpfeiler der
der objektorientierten 

467
00:22:05,440 --> 00:22:08,920
Programmierung kommen wir dann 
gleich drauf zu, warum das 

468
00:22:08,920 --> 00:22:12,120
einfach praktisch ist, ja. 
Mhm, da, damit wirst du es also 

469
00:22:12,120 --> 00:22:14,320
dann so quasi beantworten. 
Durch diese 4 Grundpfeiler 

470
00:22:14,320 --> 00:22:17,400
verstellen. 
Ja genau, es ergibt sich ja zum 

471
00:22:17,400 --> 00:22:20,560
Beispiel, dass du, dass es 
praktischer ist, im Code zu 

472
00:22:20,560 --> 00:22:24,480
sagen, Pass mal auf, das sind 
alles meine Datenpunkte und ich 

473
00:22:24,480 --> 00:22:27,720
brauche jetzt statistische 
Auswertung, zum Beispiel ja so, 

474
00:22:27,720 --> 00:22:31,520
und jetzt jetzt kann ich zum 
Beispiel eine Instanz von so 

475
00:22:31,520 --> 00:22:35,760
einer Klasse erstellen, die zum 
Beispiel Statistics heißt, und 

476
00:22:35,760 --> 00:22:39,040
jetzt habe ich eine, wenn ich 
Klassen hab, dann habe ich eine 

477
00:22:39,040 --> 00:22:42,480
spezielle Funktion, und das 
nennt die nennt sich der 

478
00:22:42,480 --> 00:22:45,440
Konstruktor. 
Also es ist auch. 

479
00:22:45,440 --> 00:22:48,880
Also ich hab ja gerade gesagt, 
Klassen sind im Prinzip nichts 

480
00:22:48,880 --> 00:22:52,200
anderes als nen neues 
Abstraktionslevel über den 

481
00:22:52,200 --> 00:22:56,160
Funktionen und Klassen können 
Funktionen haben und eine es 

482
00:22:56,160 --> 00:22:59,400
gibt aber eine sehr spezielle 
Methode, das ist nämlich die 

483
00:22:59,400 --> 00:23:03,600
Methode quasi die aufgerufen 
wird, wenn aus diesem aus diesem

484
00:23:03,600 --> 00:23:06,960
Stück Code, das ja feststeht, 
eine neue Instanz, wie man sagt,

485
00:23:06,960 --> 00:23:08,800
ein Objekt einer Klasse 
hergestellt wird. 

486
00:23:08,800 --> 00:23:12,240
Ja, das nennt sich der 
Konstruktor so und der 

487
00:23:12,240 --> 00:23:14,600
Konstruktor. 
In unserer Statistikfunktion der

488
00:23:14,600 --> 00:23:19,000
würde typischerweise jetzt 
einmal dieses Feld von Zahlen 

489
00:23:19,000 --> 00:23:22,160
bekommen, auf der die Statistik 
dann ausgeführt werden soll, 

490
00:23:22,720 --> 00:23:26,080
also den Array von Nummern zum 
Beispiel ja im Konstruktor. 

491
00:23:26,960 --> 00:23:29,760
Und jetzt gibt es was Neues 
jetzt, und das ist wichtig, 

492
00:23:30,000 --> 00:23:34,320
jetzt können in der Klasse und 
den Objekten können jetzt quasi 

493
00:23:34,320 --> 00:23:36,080
die Daten, die ich normalerweise
hab. 

494
00:23:36,720 --> 00:23:39,600
Die typischerweise beim beim in 
der nur Prozeduralen, nur 

495
00:23:39,600 --> 00:23:42,960
funktionalen Programmiersprache 
immer nur außen gehalten werden.

496
00:23:42,960 --> 00:23:45,400
Ich muss ja immer, ich hab ja 
beim Programmieren immer zu tun 

497
00:23:45,400 --> 00:23:48,240
mit Speicher und mit variablen, 
ich muss mir ja mal was merken 

498
00:23:48,400 --> 00:23:52,000
und dann kann ich irgendwie ne 
Logik drauf aufrufen ne so 

499
00:23:52,000 --> 00:23:55,280
unsere Average Funktion im 
ersten Falle da muss ich quasi 

500
00:23:55,280 --> 00:23:58,720
mir ne mir mir die die Zahlen 
von außen merken die ich 

501
00:23:58,720 --> 00:24:00,480
überhaupt auf denen ich der 
Statistik machen will, dann 

502
00:24:00,480 --> 00:24:03,280
packe ich sie in ne Funktion und
dann kriege ich n wert zurück. 

503
00:24:03,880 --> 00:24:05,440
Dann muss ich mir immer noch 
außen merken, wenn ich die 

504
00:24:05,440 --> 00:24:07,960
zweite Funktion auf aufrufen 
will und so weiter ja und ich 

505
00:24:07,960 --> 00:24:10,400
muss mir auch das Ergebnis 
wieder außen merken und wenn ich

506
00:24:10,400 --> 00:24:12,480
jetzt quasi mit dem Average 
irgendwas rechnen will, dann 

507
00:24:12,480 --> 00:24:15,600
muss ich es wieder von außen 
reinkippen, wenn ich Klassen und

508
00:24:15,600 --> 00:24:19,760
Instanzen habe, dann werden die 
Daten auch gebunden in der 

509
00:24:19,760 --> 00:24:21,080
Instanz. 
Also wenn ich jetzt diesen 

510
00:24:21,080 --> 00:24:24,720
Konstruktor Aufrufe und übergebe
einmal dieses Feld von Nummern, 

511
00:24:25,120 --> 00:24:28,520
dann kann ich eine einen 
Speicher anlegen und das nennt 

512
00:24:28,520 --> 00:24:31,600
man member Variablen. 
Die gehören dann nur dieser 

513
00:24:31,600 --> 00:24:33,840
Instanz, die ich dann aufgerufen
hab, dieser Klasse. 

514
00:24:33,840 --> 00:24:38,360
Das heißt, diese Instanz der 
Statistikklasse merkt sich die 

515
00:24:38,360 --> 00:24:40,920
Zahlen, auf denen ich später 
arbeiten will und das Macht auch

516
00:24:40,920 --> 00:24:43,360
Sinn, weil ich zum Beispiel 
verschiedene statistische 

517
00:24:43,360 --> 00:24:45,320
Auswertungen immer wieder auf 
diesen gleichen Zahlen machen 

518
00:24:45,320 --> 00:24:47,920
muss, und das heißt, dann habe 
ich also ne member Variable, zum

519
00:24:47,920 --> 00:24:51,120
Beispiel Data, das ist die 
Datengrundlage, wenn ich jetzt 

520
00:24:51,120 --> 00:24:55,320
die Funktion Average aufrufe, 
dann kann ich die aufrufen, ohne

521
00:24:55,320 --> 00:24:57,040
dass ich irgendwelche Sachen 
übergebe. 

522
00:24:57,040 --> 00:24:59,680
Ja, jetzt würde ich quasi. 
Von der Instanz, die ich 

523
00:24:59,680 --> 00:25:02,200
bekomme, und das muss man auch 
erstmal machen. 

524
00:25:02,200 --> 00:25:06,200
Du sagst dann quasi New 
Statistics Klasse und der 

525
00:25:06,200 --> 00:25:08,160
übergibst du jetzt das Feld, 
dann wird der Konstruktor 

526
00:25:08,160 --> 00:25:11,840
aufgerufen und dann bekommst du 
eine eine Variable in die Hand, 

527
00:25:11,840 --> 00:25:14,640
die heißt dann irgendwie zum 
Beispiel Statistics 

528
00:25:14,640 --> 00:25:16,560
kleingeschrieben oder 
irgendsowas, also macht man das 

529
00:25:16,560 --> 00:25:20,400
normalerweise so und und das 
repräsentiert jetzt quasi ein 

530
00:25:20,400 --> 00:25:24,400
Objekt der statistiks Klasse. 
Was da drin schon Daten hat, 

531
00:25:24,400 --> 00:25:27,040
gespeichert alles für mich ja, 
nämlich zum Beispiel die also, 

532
00:25:27,040 --> 00:25:28,560
die in dem Fall die ganzen 
Nummern. 

533
00:25:29,040 --> 00:25:31,640
Und jetzt rufe ich nur noch auf 
Statistics Punkt Average Klammer

534
00:25:31,640 --> 00:25:34,960
auf Klammer zu und muss nicht 
mehr die Daten übergeben, weil 

535
00:25:34,960 --> 00:25:40,040
die sind quasi schon Intrinsisch
mit eingebaut in die Instanz aus

536
00:25:40,040 --> 00:25:43,560
diesem Average Call kriege ich 
quasi das Ergebnis direkt raus. 

537
00:25:43,560 --> 00:25:46,720
Ja und vom Programmieren her 
sieht so aus, dass ich in der 

538
00:25:46,720 --> 00:25:50,520
Klasse Statistik habe ich die 
Methode Average ist eine ganz 

539
00:25:50,520 --> 00:25:54,000
normale Funktion. 
Erstmal von außen gesehen, aber 

540
00:25:54,320 --> 00:25:58,080
da sie in der Klasse definiert 
wurde, wird das jetzt eine 

541
00:25:58,080 --> 00:26:02,400
Member Funktion, eine sogenannte
ja also sie sie ist aufrufbar 

542
00:26:02,960 --> 00:26:06,960
nur und sinnvoll nur wenn ich 
vorher eine Instanz erzeugt habe

543
00:26:06,960 --> 00:26:10,240
über den Konstruktor, ja dann 
kann ich diese Funktion Average 

544
00:26:10,240 --> 00:26:12,760
aufrufen und dann kann ich mich 
auch und das sieht man als 

545
00:26:12,760 --> 00:26:15,520
Programmierer, ich kann mich 
dann innerhalb dieser Funktion. 

546
00:26:16,560 --> 00:26:19,840
Auf die Daten beziehen, die der 
Konstruktor abgespeichert hat, 

547
00:26:19,840 --> 00:26:21,600
vorher. 
Typischerweise ist das This oder

548
00:26:21,600 --> 00:26:24,000
Self, also viele 
Programmiersprachen machen das 

549
00:26:24,000 --> 00:26:26,600
klar, wo kommen jetzt meine 
Daten her? 

550
00:26:26,600 --> 00:26:31,680
Ja dann kann ich nämlich This 
Punkt Data adressieren oder Self

551
00:26:31,680 --> 00:26:34,880
Punkt Data im Python ja This ist
mehr so das javascript oder C 

552
00:26:34,880 --> 00:26:38,360
plus Plus und im Python heißt 
das Self ja um zu sagen das sind

553
00:26:38,360 --> 00:26:39,840
meine Daten mehr oder weniger 
ja. 

554
00:26:40,160 --> 00:26:44,680
Du hast jetzt Methoden gesagt 
und Funktionen ist das Synonym. 

555
00:26:44,680 --> 00:26:46,320
Ist das das Gleiche eigentlich 
oder? 

556
00:26:46,880 --> 00:26:51,120
Also ja, es sind alles 
Funktionen, aber es gibt quasi 2

557
00:26:51,120 --> 00:26:54,160
neue Arten von von Funktionen. 
Es gibt diejenigen, die in der 

558
00:26:54,160 --> 00:26:57,520
in in der Klasse gebunden sind, 
die Member Funktionen und es 

559
00:26:57,520 --> 00:27:00,640
gibt dann auch noch andere 
statische Funktionen, nennt man 

560
00:27:00,640 --> 00:27:04,320
das, das ist wichtig, die kann 
ich, die sind auch quasi 

561
00:27:04,320 --> 00:27:09,120
geschützt von der Klasse die 
funktionieren aber ohne Instanz.

562
00:27:09,960 --> 00:27:12,400
Das ist im Prinzip eigentlich 
nur ne Adresserweiterung von der

563
00:27:12,400 --> 00:27:14,600
Funktion, da sortier ich quasi 
die nur zusammen. 

564
00:27:14,600 --> 00:27:16,640
Die funktioniert eigentlich wie 
ne alleinstehende Funktion, so 

565
00:27:16,640 --> 00:27:19,400
kann man sich es vorstellen, 
aber ich sage halt zum Beispiel 

566
00:27:19,400 --> 00:27:24,400
Statistik, Punkt, Average und 
dann hat die aber keine Daten, 

567
00:27:24,400 --> 00:27:26,360
kann die sich nicht auf Daten 
beziehen, da müsste ich jetzt 

568
00:27:26,360 --> 00:27:28,240
wieder alle Zahlen eingeben von 
außen. 

569
00:27:28,240 --> 00:27:30,480
Ja würde jetzt in dem Beispiel 
keinen Sinn machen, aber das 

570
00:27:30,480 --> 00:27:33,840
gibt es ja also Funktion ist das
generelle Ding und wenn man 

571
00:27:33,840 --> 00:27:36,480
jetzt objektorientiert spricht, 
dann hat man 2 neue Arten von 

572
00:27:36,480 --> 00:27:38,800
Funktionen, nämlich die member 
Funktion. 

573
00:27:39,040 --> 00:27:41,840
Sind die oder instanzfunktionen 
und statische Funktionen das 

574
00:27:41,840 --> 00:27:44,360
sind die auf Klassenlevel. 
Das fand ich jetzt sehr 

575
00:27:44,360 --> 00:27:46,480
hilfreich. 
Längst hab ich gefragt, ob 

576
00:27:46,480 --> 00:27:48,640
Methoden und Funktionen das 
Gleiche sind. 

577
00:27:49,520 --> 00:27:52,680
Ja, ich würde sagen Funktion ist
allgemeiner ne und Methoden sind

578
00:27:52,680 --> 00:27:56,160
wenn man sagt Methode, dann 
meint man immer eigentlich ne ne

579
00:27:56,160 --> 00:28:01,200
Methode der Instanz, also eine 
die eine Funktion die erst dann 

580
00:28:01,200 --> 00:28:04,040
verfügbar ist wenn ich vorher ne
Instanz einer Klasse erzeugt 

581
00:28:04,040 --> 00:28:06,000
hab. 
Das ist das spezielle Wort 

582
00:28:06,000 --> 00:28:08,280
Methoden, ansonsten sagt man 
eher wenn man es wenn man nicht.

583
00:28:08,680 --> 00:28:11,440
Wenn man nicht genau sagen will,
dass das jetzt ne member 

584
00:28:11,440 --> 00:28:12,960
Funktion ist. 
Ich nenn es immer member 

585
00:28:12,960 --> 00:28:14,920
function. 
Ja und dann sagt man ja es ist 

586
00:28:14,920 --> 00:28:17,480
irgendeine Funktion, aber wenn 
man sagt ne Methode auf dem 

587
00:28:17,480 --> 00:28:19,800
Deutschen, dann meint man 
eigentlich eine Funktion einer 

588
00:28:19,800 --> 00:28:24,120
Instanz genau und jetzt es gibt 
4 Kernkonzepte der 

589
00:28:24,120 --> 00:28:26,800
objektorientierten 
Programmierung, da sagt man das 

590
00:28:26,800 --> 00:28:31,560
ist Abstraktion, kapselung, 
Vererbung und Polymorphie die 

591
00:28:31,560 --> 00:28:34,480
kommen jetzt quasi als von dem 
was wir jetzt so gehört und 

592
00:28:34,480 --> 00:28:36,640
verstanden haben kommen die so n
bisschen mit ja. 

593
00:28:37,280 --> 00:28:40,320
Und warum will ich das haben? 
Ja, ich also wenn jetzt Code ne 

594
00:28:40,320 --> 00:28:43,720
Codebase groß wird und wenn zum 
Beispiel viele Entwickler 

595
00:28:43,720 --> 00:28:47,080
irgendwas machen, ja dann muss 
ich Übersicht bekommen. 

596
00:28:47,080 --> 00:28:49,080
Ja das ist so n bisschen man 
kann so n bisschen vergleichen 

597
00:28:49,080 --> 00:28:52,560
mit mit einem Word Dokument wo 
ich irgendwie Überschriften 

598
00:28:52,560 --> 00:28:55,200
einfalten kann natürlich ich 
wenn ich so n 400 Seiten 

599
00:28:55,200 --> 00:28:57,320
Dokument hab und mir ne 
Übersicht verschaffen, ja dann 

600
00:28:57,600 --> 00:29:00,000
ist es irgendwie cool wenn es 
irgendwie n Inhaltsverzeichnis 

601
00:29:00,000 --> 00:29:02,080
gibt ja oder irgendwie 
Überschriften Gliederung ja 

602
00:29:02,080 --> 00:29:03,760
Sektionen die kann ich halt 
falten ja. 

603
00:29:04,320 --> 00:29:06,880
So n Akkordeon Ding da ne ja. 
Ja, sowas in der Art. 

604
00:29:06,880 --> 00:29:09,920
Ja und ich und und wenn ich so 
ne wenn ich so Zusammenfassung 

605
00:29:09,920 --> 00:29:13,520
habe von von Überschriften und 
so weiter das kann ich halt 

606
00:29:13,520 --> 00:29:16,280
machen wenn ich Klassen habe, 
dann hab ich quasi, dann kann 

607
00:29:16,280 --> 00:29:19,040
ich quasi für diese Klasse in 
diesem Namensraum dieser klasse 

608
00:29:19,040 --> 00:29:23,680
kann ich so ne Art ganz gerne 
NAPI ja kann quasi definieren 

609
00:29:23,680 --> 00:29:27,280
was was sind die Methoden die 
man nach außen kennen muss, ja 

610
00:29:27,320 --> 00:29:30,520
man nennt das auch Public 
Message ja NT plus Plus hat das 

611
00:29:30,520 --> 00:29:32,000
auf die Spitze getrieben, da 
wird das genau. 

612
00:29:32,360 --> 00:29:34,880
Wird es genau hindefiniert. 
Du kannst nämlich ja auch 

613
00:29:34,880 --> 00:29:39,040
Funktionen brauchen können auch 
sogar member Funktionen, die 

614
00:29:39,040 --> 00:29:42,160
Hilfsfunktionen sind um das zu 
tun was deine klasse können 

615
00:29:42,160 --> 00:29:44,880
soll. 
Ja sagen wir mal du hast jetzt 

616
00:29:44,880 --> 00:29:48,320
ne ne ne ganz krasse 
statistische Auswertung was weiß

617
00:29:48,320 --> 00:29:52,080
ich fällt gerade nichts ein wo 
wo schwierige Berechnungen 

618
00:29:52,080 --> 00:29:56,160
angestellt werden müssen wo du 
quasi das diese ganze Berechnung

619
00:29:56,160 --> 00:29:58,480
auch nicht wieder in einer 
Funktion machen willst, nämlich 

620
00:29:58,480 --> 00:30:01,280
die die der Nutzer auf aufruft, 
sondern. 

621
00:30:01,600 --> 00:30:04,840
So wie ich vorher gesagt hab 567
Zeilen ne schaff ich nicht, also

622
00:30:04,840 --> 00:30:07,440
hab ich noch mal hilfsfunktionen
ne, aber diese verdammten 

623
00:30:07,440 --> 00:30:11,280
Hilfsfunktionen, die sind nur 
sinnvoll im Zusammenhang mit 

624
00:30:11,280 --> 00:30:13,680
dieser einen oberliegenden 
Funktion, die du eigentlich nach

625
00:30:13,680 --> 00:30:16,360
außen geben willst. 
So ja und jetzt kannst du also 

626
00:30:16,360 --> 00:30:18,480
in der Klasse trotzdem noch 
hilfsfunktionen schreiben und 

627
00:30:18,480 --> 00:30:21,680
auch Hilfsvariablen haben und 
Hilfsdaten und alles mögliche 

628
00:30:22,160 --> 00:30:26,120
kannst aber sagen die sind 
privat, die zeig ich nach außen 

629
00:30:26,120 --> 00:30:28,840
hin nicht. 
Nach außen hin heißt nach außen 

630
00:30:28,840 --> 00:30:31,280
zum Entwickler ja selbst wenn du
es selber schreibst, so irre ist

631
00:30:31,280 --> 00:30:33,960
das, aber man es ist ja so, dass
du viel Code schreibst und du 

632
00:30:33,960 --> 00:30:36,760
vergisst das auch wieder. 
Ja und der nächste Entwickler 

633
00:30:36,760 --> 00:30:40,440
kommt rein ja, also man versucht
mit mit diesen, mit dieser 

634
00:30:40,440 --> 00:30:43,600
objektorientierten 
Programmierung so ne Art Apis 

635
00:30:43,600 --> 00:30:45,080
auf kleinstem Level zu 
schreiben. 

636
00:30:45,080 --> 00:30:48,320
Ja ich sag halt diese Klasse, 
die soll halt das und das machen

637
00:30:48,320 --> 00:30:51,400
und das sind die Hauptfunktionen
ja und wie die das macht und und

638
00:30:51,400 --> 00:30:52,800
was ich dann noch für 
hilfsfunktionen hab, das 

639
00:30:52,800 --> 00:30:54,160
schreibe ich da auch rein in die
Klasse. 

640
00:30:54,640 --> 00:30:57,440
Kennzeichne ich aber als privat 
mehr oder weniger und dann ist 

641
00:30:57,440 --> 00:31:00,320
es total sauber und dann kann 
ich auch wenn wenn wenn wenn ich

642
00:31:00,320 --> 00:31:03,440
die weiter benutze die Klasse, 
dann mach ich quasi nichts 

643
00:31:03,440 --> 00:31:05,360
falsch, dann kann ich nicht 
falsch bedient werden. 

644
00:31:05,360 --> 00:31:09,000
Ja ich schütze mich davor den 
Code falsch aufzurufen, quasi. 

645
00:31:09,000 --> 00:31:11,280
Ja das ist so n bisschen das 
Abstraktionslevel ja. 

646
00:31:11,520 --> 00:31:13,200
Also macht es auch. 
Könnte man auch schon sagen, 

647
00:31:13,200 --> 00:31:16,240
auch auch wenn du sagst für 
größere Teams sinnvoll macht es 

648
00:31:16,240 --> 00:31:19,360
Teamarbeit auch irgendwie in 
gewisser Weise einfacher ne mit 

649
00:31:19,360 --> 00:31:20,800
mehreren Leuten am Code zu 
arbeiten. 

650
00:31:20,960 --> 00:31:22,680
Ja, auf jeden Fall. 
Genau. 

651
00:31:22,680 --> 00:31:25,640
Und Encapulation spielt da in 
die, in die in in die gleiche 

652
00:31:25,640 --> 00:31:26,240
Richtung. 
Ne. 

653
00:31:26,240 --> 00:31:28,800
Also ich hab also Abstraktion 
ist quasi ich les quasi was die 

654
00:31:28,800 --> 00:31:30,960
tun kann, das sind quasi die 
Überschriften und Encapulation 

655
00:31:30,960 --> 00:31:33,760
ist das was ich sagte, dass dass
du quasi auch diese ganzen 

656
00:31:33,760 --> 00:31:36,240
Daten, state, ja alles was du an
Hilfsvariablen brauchst und so 

657
00:31:36,240 --> 00:31:38,640
weiter das muss ich alles nicht 
wissen, das wird alles 

658
00:31:38,640 --> 00:31:41,120
weggekapselt ja ich ruf einmal 
mit dem Konstruktor das Ding 

659
00:31:41,120 --> 00:31:43,520
auf, ja zum Beispiel mit dem 
Riesen Array von Nummern. 

660
00:31:43,840 --> 00:31:46,040
So, und jetzt kann es wichtig 
sein, dass bestimmte Algorithmen

661
00:31:46,040 --> 00:31:48,160
da irgendwie Teile von diesem 
Array genommen werden. 

662
00:31:48,160 --> 00:31:50,160
Ja, bei Bildverarbeitung zum 
Beispiel, dass ich das im 

663
00:31:50,160 --> 00:31:52,720
Speicher noch mal ganz anders 
hinlege, ne immer 4 * 4 Pixel 

664
00:31:52,720 --> 00:31:55,160
werten und so weiter und sofort,
ja das weiß alles, die Klasse 

665
00:31:55,160 --> 00:31:58,720
und Instanz selbst. 
Da muss ich aber als als Nutzer,

666
00:31:58,960 --> 00:32:01,160
also Entwickler, Nutzer von 
dieser Klasse nichts von wissen,

667
00:32:01,160 --> 00:32:02,560
ja das wird also alles 
gekapselt. 

668
00:32:03,280 --> 00:32:06,320
Und ja, und ich darf dann 
bestimmte Funktionen auch nicht 

669
00:32:06,320 --> 00:32:07,680
aufrufen. 
Das verbietet mir dann sogar, 

670
00:32:07,680 --> 00:32:09,840
wenn der der Compiler kann das 
verbieten ja wenn das der 

671
00:32:09,840 --> 00:32:11,920
Entwickler gesagt hat hier, das 
ist privat, das darfst du nicht 

672
00:32:11,920 --> 00:32:14,640
direkt aufrufen von außen, dann 
darfst du es auch nicht, ja. 

673
00:32:15,200 --> 00:32:18,680
Ja, noch mal kurze Zwischenfrage
wegen mit dem zu dem, wenn es 

674
00:32:18,680 --> 00:32:21,360
gerade passt, zu dem Aufrufen. 
Du hast ja gerade gesagt, 

675
00:32:21,360 --> 00:32:25,200
Aufrufen und dann n großes Array
von von zahlen wenn ich jetzt ne

676
00:32:25,200 --> 00:32:28,200
Klasse Aufrufe krieg ich dann im
Code schon angezeigt was die 

677
00:32:28,200 --> 00:32:30,640
Klasse dann auch haben möchte 
als. 

678
00:32:31,760 --> 00:32:34,480
Input oder als als als als 
Argumente oder sowas? 

679
00:32:34,480 --> 00:32:36,720
Oder wie läuft das? 
Musst du es wissen. 

680
00:32:37,280 --> 00:32:39,280
Na ja, also du, du kannst es 
immer wissen, weil ja der 

681
00:32:39,280 --> 00:32:41,840
Quelltext irgendwo steht. 
Ja OK, kannst nachgucken. 

682
00:32:41,840 --> 00:32:44,080
Ja, also. 
Kannst du nachgucken, aber, aber

683
00:32:44,080 --> 00:32:46,160
tatsächlich ist das nachgucken 
ist dann ja auch wieder, musst 

684
00:32:46,160 --> 00:32:47,600
du ja auch wieder Source, gut 
lesen, dann musst du diese 

685
00:32:47,600 --> 00:32:49,440
ganzen public private Dinger 
wissen und sofort, ja 

686
00:32:49,760 --> 00:32:52,160
tatsächlich ist so heute durch 
die Idee ES also durch die 

687
00:32:52,160 --> 00:32:55,240
Integrated Development 
Environments im Prinzip durch 

688
00:32:55,240 --> 00:32:58,720
die Editoren und Steroids. 
Die wissen genau das, also die 

689
00:32:58,720 --> 00:33:00,560
machen du. 
Du erzeugst so ne Instanz und 

690
00:33:00,560 --> 00:33:02,920
tippst du den Punkt dahin oder 
den Fall, je nachdem welche 

691
00:33:02,920 --> 00:33:05,760
Programmiersprache um quasi 
jetzt vielleicht n 

692
00:33:05,760 --> 00:33:09,040
Methodenaufruf hinzuschreiben, 
der auf dieser Klasse da ist und

693
00:33:09,040 --> 00:33:12,160
dann passiert genau das. 
Du kriegst quasi so nen tooltip 

694
00:33:12,160 --> 00:33:15,160
Menü und dir sagt quasi deine 
Idee, Pass mal auf diese Klasse 

695
00:33:15,160 --> 00:33:18,040
hat die und die Funktion, die 
kannst du jetzt benutzen und oft

696
00:33:18,040 --> 00:33:19,720
sind die auch sehr gut 
dokumentiert, weil das sind ja 

697
00:33:19,720 --> 00:33:22,200
die Public Funktionen, dabei 
hast du ja du hast wenn du als 

698
00:33:22,200 --> 00:33:23,760
Entwickler ne Klasse geschrieben
hast. 

699
00:33:24,480 --> 00:33:26,640
Und hast bestimmte Funktionen, 
die du möchtest, dass die andere

700
00:33:26,640 --> 00:33:28,880
benutzen können. 
Und Dokumentierst du die auch im

701
00:33:28,880 --> 00:33:30,360
Code? 
Ja, und diese ganze 

702
00:33:30,360 --> 00:33:33,520
Dokumentation, diesen ganzen 
Krams, das Parsen die IDES die 

703
00:33:33,520 --> 00:33:36,080
ganze Zeit durch und das wird 
dir angezeigt, wenn du sie dann 

704
00:33:36,080 --> 00:33:37,600
benutzt. 
An der anderen Stelle, ja, und 

705
00:33:37,760 --> 00:33:40,120
das ist mega praktisch, oft 
brauchst du dann gar nicht so 

706
00:33:40,120 --> 00:33:42,560
viel lesen, ja, weil Gerrit ja 
auch ne Wahrheit ist, dass du 

707
00:33:42,560 --> 00:33:44,880
die Klassen ja auch nicht nur 
selber schreibst, sondern du 

708
00:33:44,880 --> 00:33:48,080
benutzt ja auch ganz viel Code 
von anderen als als Dependency, 

709
00:33:48,080 --> 00:33:51,040
als Third Party mit. 
Und und wie benutzt du denn 

710
00:33:51,040 --> 00:33:53,280
Third Partys? 
Ja, du benutzt deren Objekte und

711
00:33:53,280 --> 00:33:55,240
deren Klassen, ja und es wird 
dir dann ziemlich sauber 

712
00:33:55,240 --> 00:33:56,680
angezeigt. 
Wie kannst du das benutzen? 

713
00:33:56,680 --> 00:33:59,760
Ja du kannst ja auch nicht 
erwarten, dass das kann keiner 

714
00:33:59,840 --> 00:34:02,880
können, ja, dass du den ganzen 
Code den ganzen Dependency 

715
00:34:02,880 --> 00:34:06,560
source Code, den du dann wovon 
du dann 23 Funktionen brauchst 

716
00:34:06,560 --> 00:34:10,800
oder oder Funktionen die members
Methoden von Klassen, da willst 

717
00:34:10,800 --> 00:34:13,719
du nicht den ganzen Code lesen 
ja und du willst dir aber 

718
00:34:13,719 --> 00:34:15,600
trotzdem sicher sein, dass du 
das richtig benutzt. 

719
00:34:15,600 --> 00:34:18,320
Ja und insofern. 
Gibt das quasi dieses 

720
00:34:18,320 --> 00:34:20,719
objektorientierte Programm 
programmieren vor? 

721
00:34:21,280 --> 00:34:23,760
Cool, dann warst du gerade mit 
der Encapstulation durch. 

722
00:34:24,440 --> 00:34:27,679
Genau dann gibt es noch diesen 
Punkt Vererbung bei diesen 

723
00:34:27,679 --> 00:34:29,600
Pillars. 
Da steht dann immer schon nicht 

724
00:34:29,600 --> 00:34:32,960
mehr composition. 
Ich würd das jetzt dazu packen 

725
00:34:33,280 --> 00:34:35,920
an der Stelle, aber ich sag erst
mal kurz was Vererbung ist. 

726
00:34:36,719 --> 00:34:39,840
Also die Idee ist, wenn du so ne
Art ja wenn du so ne Art 

727
00:34:39,840 --> 00:34:44,960
Blaupausen hast, dass du dann 
sagst ich Erbe schon mal ne 

728
00:34:44,960 --> 00:34:48,920
ganze Menge Eigenschaften. 
Von einem bestehenden Template, 

729
00:34:48,920 --> 00:34:52,080
also ich spezifiziere das noch 
mehr aus. 

730
00:34:52,080 --> 00:34:54,000
Ich gebe jetzt mal ein Beispiel,
wir hatten ja die ganze Zeit von

731
00:34:54,000 --> 00:34:56,560
statistiks Klasse gesprochen, wo
irgendwie statistische Methoden 

732
00:34:56,560 --> 00:35:00,560
sind, ja, die könnte zum 
Beispiel von einer 

733
00:35:01,360 --> 00:35:05,360
grundlegenderen Klasse erben, 
die einfach nur Mars heißt, also

734
00:35:05,360 --> 00:35:08,960
Mathematik ja, und in der 
Mathematik Klasse sind noch viel

735
00:35:08,960 --> 00:35:11,320
grundsätzliche Funktionen drin 
oder so ne, die haben jetzt das 

736
00:35:11,320 --> 00:35:13,120
vielleicht nicht mit der 
Statistik zu tun, aber die. 

737
00:35:13,680 --> 00:35:15,600
Was weiß ich, die können 
irgendwelche trigonomenischen 

738
00:35:15,600 --> 00:35:18,240
Sachen machen, Sam und Ed und so
weiter und sofort ja. 

739
00:35:18,640 --> 00:35:20,800
Ja, das passt ja hier. 
Du hast ja vom Average schon 

740
00:35:20,800 --> 00:35:23,040
davon gesprochen, dass du ja da 
auch ne Sam bräuchtest. 

741
00:35:23,040 --> 00:35:25,200
Dann ne. 
Ja genau das, das würde passen. 

742
00:35:25,200 --> 00:35:27,520
Ja, und das gibt es halt ganz, 
ganz oft. 

743
00:35:27,520 --> 00:35:30,480
Ja, und das ist wie im Leben, 
ja, das gibt halt, wenn du 

744
00:35:30,480 --> 00:35:32,720
kannst halt Templates für alles 
machen in deinem Leben, ja und 

745
00:35:32,720 --> 00:35:36,160
dann kannst du grundsätzlichere 
und feinere ja und wenn du jetzt

746
00:35:36,160 --> 00:35:39,640
quasi die Vererbung nicht 
hättest und würdest aber das 

747
00:35:39,640 --> 00:35:41,520
statistiks Ding hinschreiben 
wollen. 

748
00:35:42,400 --> 00:35:44,680
Ja, du musst doch halt irgendwie
noch mal alles hinschreiben, was

749
00:35:44,680 --> 00:35:47,840
du dafür brauchst. 
Ja, so und eventuell ist aber in

750
00:35:47,840 --> 00:35:49,760
der in der Maßfunktion schon was
drinne. 

751
00:35:49,840 --> 00:35:53,040
Ja was du benutzen kannst. 
Ja und auf meinem Level 

752
00:35:53,040 --> 00:35:55,680
Statistics gibt es vielleicht 
noch n anderes Level, das heißt 

753
00:35:55,680 --> 00:35:59,880
was weiß ich imageprocessing 
oder irgendsowas ja weil ich 

754
00:35:59,880 --> 00:36:01,520
jetzt nicht Statistik machen 
will, sondern ich will jetzt 

755
00:36:01,520 --> 00:36:03,840
irgendwie imageprocessing 
Algorithmen machen, so da brauch

756
00:36:03,840 --> 00:36:06,480
ich aber auch Mathematik 
Algorithmen ja und wieder die 

757
00:36:06,480 --> 00:36:08,800
gleichen so und jetzt kommt 
wieder das Konzept Don't repeat 

758
00:36:08,800 --> 00:36:10,560
yourself ja wie Krieg ich das 
jetzt hin? 

759
00:36:11,040 --> 00:36:14,240
Das jetzt irgendwie nen nen 
Image Processing klasse und ne 

760
00:36:14,240 --> 00:36:17,800
statistics klasse nicht wieder 
irgendwelche grundlegenden 

761
00:36:17,800 --> 00:36:21,280
mathematischen Operationen 
implementiert, sondern dass die 

762
00:36:21,280 --> 00:36:22,880
irgendwie beide das haben 
können. 

763
00:36:22,880 --> 00:36:26,880
Ne und jetzt kommt das Konzept 
der Vererbung an Start und jetzt

764
00:36:26,880 --> 00:36:30,720
sagt man OK ich bau halt meinen 
Code so auf, dass ich versuche 

765
00:36:30,720 --> 00:36:34,160
alle Probleme so zu schneiden 
und zwar jetzt nicht nur in 

766
00:36:34,160 --> 00:36:36,160
Funktion zu schneiden sondern in
Klassen zu schneiden, dass ich 

767
00:36:36,160 --> 00:36:39,760
halt grundsätzlichere Klassen 
habe und feinere Klassen. 

768
00:36:40,400 --> 00:36:43,280
Und feinere Klassen können quasi
von Grundsätzlicheren Erben. 

769
00:36:43,280 --> 00:36:46,880
Ja, und jetzt sagt man zum 
Beispiel Statistics erbt von 

770
00:36:46,880 --> 00:36:50,960
Mars ja und Image Processing 
erbt vielleicht auch von Mars, 

771
00:36:50,960 --> 00:36:53,280
ja, es kann nämlich so sein, 
dass verschiedene Klassen auch 

772
00:36:53,280 --> 00:36:55,080
von der gleichen Base Klasse 
erben, ja, und in manchen 

773
00:36:56,000 --> 00:36:58,360
Programmiersprachen ist es sogar
so krass, dass man, dass man 

774
00:36:58,360 --> 00:37:00,800
grundsätzlich, dass man so in 
der Programmiersprache sogar 

775
00:37:00,960 --> 00:37:04,640
angelegt hat, ne Object als die 
Basis, Basis, Basis, Klasse 

776
00:37:04,640 --> 00:37:06,640
aller Klassen, ja, da stecken 
halt irgendwie so ganz 

777
00:37:06,640 --> 00:37:08,600
grundsätzliche Dinger drin, wie 
irgend weiß ich nicht. 

778
00:37:08,960 --> 00:37:11,600
Zum Beispiel wie wie pack ich 
irgendwas auf n Screen raus? 

779
00:37:11,600 --> 00:37:14,400
Ja so n Print oder Irgendsowas 
ja dann hab ich quasi ne 

780
00:37:14,400 --> 00:37:18,240
erbhierarchie und da erbt 
erstmal jeder von Objekt ja so 

781
00:37:18,240 --> 00:37:20,080
und dann erben die noch weiter 
und so weiter dann krieg ich so 

782
00:37:20,080 --> 00:37:22,480
baumierarchien ne so richtige 
große Graphen. 

783
00:37:22,480 --> 00:37:26,000
Ja Java ist so ne Sprache, da 
erbt immer alles von allem ach 

784
00:37:26,000 --> 00:37:28,600
das da, da hast du immer ganz 
viele so und dann kannst du 

785
00:37:28,600 --> 00:37:31,320
erstmal gucken wer und dann erb 
ich von der Klasse und die erbt 

786
00:37:31,320 --> 00:37:33,280
noch mal von wem, da musst du 
erstmal verstehen wer da alles 

787
00:37:33,280 --> 00:37:37,360
geerbt hat ja und was heißt 
erben heißt quasi du erbst. 

788
00:37:37,920 --> 00:37:40,600
Die öffentlich gemachten 
Funktionen, die öffentlich 

789
00:37:40,600 --> 00:37:43,720
gemachten Members, die erbst du 
ja die Privaten interessieren 

790
00:37:43,720 --> 00:37:45,200
dich, die hast die Funktion. 
Hast du dann einfach zur 

791
00:37:45,200 --> 00:37:48,520
Funktion, aber du erbst dann 
quasi die die Klassen mit so n 

792
00:37:48,520 --> 00:37:49,800
so n. 
Typisches Beispiel ist immer, 

793
00:37:49,800 --> 00:37:52,320
was ich nicht mag, aber hast ne 
ne Base klasse, die heißt Animal

794
00:37:52,320 --> 00:37:54,480
und dann hast du quasi die 
geerbten Klassen, die ist dann 

795
00:37:54,480 --> 00:37:59,240
quasi nen Dog und ne Cat und 
Word oder irgendsowas ja und 

796
00:37:59,240 --> 00:38:01,680
dann dann gibt es in der Animal 
Klasse gibt es ne Funktion die 

797
00:38:01,680 --> 00:38:04,720
heißt irgendwie sound ja. 
Und dann haben die alle den dann

798
00:38:04,720 --> 00:38:06,760
erben die alle diese 
Soundmethode und die kannst du 

799
00:38:06,760 --> 00:38:09,040
dann auch überschreiben. 
Ja also das das dann quasi dann 

800
00:38:09,040 --> 00:38:13,040
sagst du in deiner Hundklasse 
sagst du Sound kommt Bark raus 

801
00:38:13,040 --> 00:38:15,760
oder irgendsowas ja und in der 
in der Katze kommt irgendwie 

802
00:38:15,760 --> 00:38:20,640
miau und so weiter ja und in der
in der so ist das ja so und in 

803
00:38:20,640 --> 00:38:23,360
der Animal Klasse würde man 
sagen OK ich in der animal 

804
00:38:23,360 --> 00:38:25,560
Klasse hab ich zwar die Funktion
Sound aber die mach ich quasi 

805
00:38:25,560 --> 00:38:27,840
nur als Interface, ich will 
quasi zwingen, dass alle die von

806
00:38:27,840 --> 00:38:30,840
mir erben mal irgendwie nen 
Sound n Tier sound irgendwie 

807
00:38:30,840 --> 00:38:33,400
machen können ja. 
Da kann ich zum Beispiel sagen, 

808
00:38:33,400 --> 00:38:35,520
und das sind jetzt alles noch so
Konzepte, da können wir nicht 

809
00:38:35,520 --> 00:38:38,360
alles drauf eingehen, aber ich 
kann dann sagen, ich hab das ist

810
00:38:38,360 --> 00:38:41,200
Abstraktion, ich hab einfach nur
n Interface Sound und ich zwinge

811
00:38:41,200 --> 00:38:44,640
alle, die mich erben, das kann 
man auch angeben, wird dann ne 

812
00:38:44,640 --> 00:38:48,280
pure abstrakte Funktion quasi. 
Ich zwinge alle, dass die dieses

813
00:38:48,280 --> 00:38:51,040
Interface implementieren müssen.
Ja und je nachdem was ich dann 

814
00:38:51,040 --> 00:38:54,960
bin für nen Animal für nen Teal 
quasi später im Code ja mach ich

815
00:38:54,960 --> 00:38:58,160
dann halt irgendwie miau oder 
oder ich Belle oder irgendwas 

816
00:38:58,160 --> 00:39:00,160
ja. 
Ich, ich, ich mein, man kann ja 

817
00:39:00,160 --> 00:39:02,560
mal, das ist n schönes Bild, 
aber es hat so so wenig mit der 

818
00:39:02,560 --> 00:39:06,000
Realität zu tun, weil kein 
Mensch irgendwelche Jaus und 

819
00:39:06,000 --> 00:39:07,520
Animal ist irgendwie 
programmiert, das macht ja 

820
00:39:07,520 --> 00:39:11,320
keinen Sinn mehr. 
Ja tatsächlich hab ich das auch 

821
00:39:11,320 --> 00:39:14,080
gerade nicht gedacht, es steht 
aber trotzdem in allen 

822
00:39:14,080 --> 00:39:16,600
Lehrbüchern, das nervt total. 
Ja, aber ich wollt das, wollt 

823
00:39:16,600 --> 00:39:18,880
ich mal so sagen, Bill Bob 
bisschen abgenervt ne Scheiße, 

824
00:39:19,520 --> 00:39:21,960
ja tatsächlich, es steht das in 
den Lehrbüchern, deswegen kommt 

825
00:39:21,960 --> 00:39:24,400
es wahrscheinlich auch bei Deep 
Sea, Gon Tschechibity und so 

826
00:39:24,400 --> 00:39:26,800
raus. 
Wahrscheinlich, wenn du die 

827
00:39:26,800 --> 00:39:28,960
nämlich fragst, die die machen 
auch gerne gleich so n Animal 

828
00:39:28,960 --> 00:39:31,400
Dog und so weiter Beispiel was 
ich da irgendwie vorstellen 

829
00:39:31,400 --> 00:39:34,080
kann, ne, aber jetzt will ich 
noch eine Sache sagen und die 

830
00:39:34,080 --> 00:39:36,880
die liegt da jetzt immer auf 
diesem Level nicht man kann sich

831
00:39:36,880 --> 00:39:39,040
es auch so vorstellen, wenn man 
verstehen will was ist 

832
00:39:39,200 --> 00:39:42,080
Vererbung, dann sagt man immer 
im Englischen sagt man das ist 

833
00:39:42,080 --> 00:39:45,920
eine ist Verwandtschaft, also 
das ist nicht das Wort ist also 

834
00:39:46,000 --> 00:39:50,480
ist eine, ja dann kann man immer
so also ein Hund ist ein Tier. 

835
00:39:51,520 --> 00:39:53,840
Und deswegen hab ich Tier als 
Base klasse und dann erbt er es 

836
00:39:53,840 --> 00:39:54,960
ja. 
Das kann ich natürlich, ich 

837
00:39:55,040 --> 00:39:59,440
könnte sagen ne Statistik ist ne
Mathematik so ja dann dann hab 

838
00:39:59,440 --> 00:40:02,800
ich das halt geerbt, ja. 
Burkhard war das alles zur 

839
00:40:03,280 --> 00:40:05,320
Färbung. 
Du hattest glaub ich noch was 

840
00:40:05,320 --> 00:40:06,960
anderes erwähnt. 
Genau. 

841
00:40:07,280 --> 00:40:10,240
Es hat sich rausgestellt, dass 
dieses ganze Vererbungsgedöns 

842
00:40:10,880 --> 00:40:13,000
gar nicht so cool ist. 
Ja, wenn ich den Code 

843
00:40:13,000 --> 00:40:16,320
strukturieren will, warum sich 
das rausgestellt hat, ist jetzt 

844
00:40:16,320 --> 00:40:17,840
auch noch mal ne eigene Folge, 
aber. 

845
00:40:18,640 --> 00:40:20,480
Also ich kann halt nicht, ich 
kann halt ganz schwer nur 

846
00:40:20,480 --> 00:40:23,040
teilweise vererben. 
Ja das so ein Problem ist. 

847
00:40:23,280 --> 00:40:27,200
Ich muss halt echte 
Realitätsdinge so schaffen zu 

848
00:40:27,200 --> 00:40:30,720
abstrahieren, dass ich halt 
nicht zu viel und nicht zu wenig

849
00:40:30,720 --> 00:40:33,120
Erbe vererbe und dann auch vor 
allen Dingen für die ganzen 

850
00:40:33,120 --> 00:40:35,120
Baseklassen nicht und es stellt 
sich raus, dass es gar nicht so 

851
00:40:35,120 --> 00:40:37,120
einfach ist. 
Ja, denn das hat man schon sehr 

852
00:40:37,120 --> 00:40:41,280
früh festgestellt, es gibt nen 
ganz bekanntes Buch, 1994 

853
00:40:41,280 --> 00:40:45,200
erschienen Design per Dance 
Elements of reusible Code. 

854
00:40:45,840 --> 00:40:49,040
Besser bekannt als das Gang of 
Four Boof Goof. 

855
00:40:49,920 --> 00:40:51,920
Ich weiß gar nicht mehr, ob das 
heute noch so bekannt ist, aber 

856
00:40:51,920 --> 00:40:54,480
so in in in meinem Alter war das
irgendwie damals so ne 

857
00:40:54,480 --> 00:40:57,720
Pflichtlektüre, das war so ne 
Bibel, ja, weil es kam halt 

858
00:40:57,720 --> 00:40:59,840
diese objektorientierte 
Programmierung auf und es kam 

859
00:40:59,840 --> 00:41:02,960
vor allen Dingen C plus plus 
auf, das war das war so der 

860
00:41:02,960 --> 00:41:06,160
Auslöser C plus plus halt ne 
unglaublich mächtige Sprache und

861
00:41:06,160 --> 00:41:09,200
C plus plus implementiert diese 
gesamte Objektorientierung. 

862
00:41:09,760 --> 00:41:11,920
In allen Facetten komplett 
durch. 

863
00:41:11,920 --> 00:41:14,560
Ja, da kannst du alles machen 
mit abstrakten Klassen voll 

864
00:41:14,560 --> 00:41:18,240
abstrakten Klassen, Vererbung 
und so weiter und sofort und man

865
00:41:18,240 --> 00:41:21,280
war n bisschen überfordert und 
es und dann gab es dieses Buch 

866
00:41:21,280 --> 00:41:24,040
von diesen 4 sehr guten 
Softwareentwicklern, die 

867
00:41:24,040 --> 00:41:28,080
versucht haben, das mal n 
bisschen auf zu, ja n bisschen 

868
00:41:28,080 --> 00:41:30,880
auf zu aufzuschreiben, was man 
überhaupt jetzt damit alles 

869
00:41:30,880 --> 00:41:33,320
machen kann. 
Ja, also selbst wir sprechen ja 

870
00:41:33,320 --> 00:41:36,320
jetzt gerade n bisschen drüber, 
das ist n dickes Buch, was quasi

871
00:41:36,320 --> 00:41:39,120
sehr. 
Abstrakt, einfach nur mal 

872
00:41:39,120 --> 00:41:42,000
erkennt gegeben diesem einen 
Konzept, dass ich dieser 

873
00:41:42,000 --> 00:41:44,480
Funktion noch hinzufüge, dass 
ich so ne Art Templates hab und 

874
00:41:44,480 --> 00:41:47,600
Instanzen von diesen Templates 
und wie ich jetzt mit diesen 

875
00:41:47,600 --> 00:41:50,240
Instanzen von den Templates, von
denen ja viele existieren 

876
00:41:50,240 --> 00:41:52,640
können, zu Runtime, wie wie kann
ich die jetzt in Beziehung 

877
00:41:52,640 --> 00:41:54,400
setzen, was mach ich damit alles
da ist? 

878
00:41:54,400 --> 00:41:57,840
N Riesen Buch entstanden, ne, 
aber Fazit von diesem Buch war 

879
00:41:58,160 --> 00:42:00,960
nutzt mal lieber nicht so viel 
Vererbung, das führt ins Chaos 

880
00:42:01,440 --> 00:42:05,080
ja und so n bisschen die 
Grundessenz war, dass es nämlich

881
00:42:05,080 --> 00:42:07,600
sehr kompliziertes. 
Wenn man andauernd nur vererbt, 

882
00:42:07,600 --> 00:42:12,520
dann fängt man nämlich an, beim 
Design von den Klassen sich n 

883
00:42:12,520 --> 00:42:15,480
Bein abzubrechen, weil weil ich 
ich hab dann ganz oft passt das 

884
00:42:15,480 --> 00:42:18,400
nicht so ganz genau. 
Ich erb dann zu viele von meiner

885
00:42:18,400 --> 00:42:20,440
von meinem parent Funktion, die 
ich eigentlich gar nicht 

886
00:42:20,440 --> 00:42:21,560
brauche. 
Ja und dann wird es 

887
00:42:21,560 --> 00:42:24,120
unübersichtlich und ich sind es 
quasi wenn ich als Programmierer

888
00:42:24,120 --> 00:42:26,200
ne sehr tief geerbte klasse 
habe, dann hab ich irgendwie so 

889
00:42:26,200 --> 00:42:28,520
n riesen Stapel an Funktionen ne
weiß ich auch nicht mehr welche 

890
00:42:28,520 --> 00:42:31,440
ich nehmen soll uns fort ja. 
Und es wird relativ starr und 

891
00:42:31,440 --> 00:42:33,880
man kann es nicht mehr so 
einfach durch die Gegend ändern,

892
00:42:33,880 --> 00:42:36,040
wenn man, wenn man mal größeres 
refactoring macht, dann muss ich

893
00:42:36,040 --> 00:42:38,320
irgendwie so ganze 
Hierarchiebäume und so weiter 

894
00:42:38,320 --> 00:42:40,880
aufbrechen und muss auf einmal 
in ganz vielen Stellen Code was 

895
00:42:40,880 --> 00:42:43,520
ändern und weil alles irgendwie 
in so einer riesen Hierarchie 

896
00:42:43,520 --> 00:42:46,920
zusammenhängt, hab ich so riesen
restrukturierungsgedöns und so 

897
00:42:46,920 --> 00:42:50,080
weiter und man hatte damit, das 
war früher wirklich Riesenthema 

898
00:42:50,480 --> 00:42:53,520
so n so n klassendesign wenn ich
mir das einmal überlegt hab, so 

899
00:42:53,520 --> 00:42:56,160
das ist nicht mehr so einfach zu
refaktorisieren wenn ich den 

900
00:42:56,160 --> 00:42:58,640
Code einmal eingeschrieben hab 
war es und dann große Große. 

901
00:42:59,200 --> 00:43:00,040
Große, große Sachen. 
Ja. 

902
00:43:00,040 --> 00:43:03,120
Wenn ich mir aber was falsch 
überlegt hab, dann hab ich 

903
00:43:03,120 --> 00:43:05,840
richtig designprobleme in meinem
Code, das ist so n bisschen wie 

904
00:43:05,840 --> 00:43:10,000
wenn ich irgendwie im Hotel 
irgendwie den den Zulieferer LKW

905
00:43:10,000 --> 00:43:12,120
dann irgendwie in die 2. 
Etage geplant hab und der muss 

906
00:43:12,120 --> 00:43:14,520
halt immer irgendwie erstmal das
Parkhaus hoch und dann oben 

907
00:43:14,520 --> 00:43:16,880
zuliefern oder irgend so was das
das ist Blödsinn, das Krieg ich 

908
00:43:16,880 --> 00:43:20,000
nicht so schnell nicht mehr weg.
Ja und diese Vererbungssachen 

909
00:43:20,000 --> 00:43:22,200
führen dazu, dass ich dann diese
starren Strukturen hab, die ich 

910
00:43:22,200 --> 00:43:27,040
nicht mehr schnell ändern kann 
ne und man sagt die Komposition 

911
00:43:27,520 --> 00:43:31,040
Composition im Englischen. 
Ist das überlegenere Pattern ne 

912
00:43:31,520 --> 00:43:33,720
so jetzt kurz, was heißt 
Komposition? 

913
00:43:33,720 --> 00:43:36,080
Ne jetzt? 
Wir haben ja verschiedene 

914
00:43:36,080 --> 00:43:37,680
Klassen, sehr viel verschiedene 
Klassen und wir haben 

915
00:43:37,680 --> 00:43:39,920
verschiedene Instanzen davon 
jetzt kannst jetzt kann ich wenn

916
00:43:39,920 --> 00:43:42,160
ich während ich sage wenn ich 
jemandem Erbe, dann bin ich 

917
00:43:42,160 --> 00:43:46,320
jemand, ja wenn ich meine 
statistikklasse bin, dann bin 

918
00:43:46,320 --> 00:43:50,400
ich ne matheklasse wenn ich von 
der Erbe ich könnte aber auch 

919
00:43:50,400 --> 00:43:54,320
sagen Ich heiße jetzt statistics
und ich Erbe von gar keinem ich 

920
00:43:54,320 --> 00:43:56,400
Erbe nicht ich habe einfach die 
Klasse statistics. 

921
00:43:57,120 --> 00:44:00,360
Jetzt brauch ich bestimmte 
Mathefunktionen, aber nur ganz 

922
00:44:00,360 --> 00:44:02,880
bestimmte. 
Ja, und in der Maß Class sind 

923
00:44:02,880 --> 00:44:06,880
vielleicht 120 Mathefunktionen 
ne daraus brauch ich jetzt 3. 

924
00:44:07,600 --> 00:44:11,520
So jetzt sag ich mir ich hab 
eine Mathe Instanz ist noch 

925
00:44:11,520 --> 00:44:15,560
dabei ja und das nennt sich 
Komponieren ist jetzt und denn 

926
00:44:15,560 --> 00:44:19,320
ich denn eine innerhalb einer 
Klasse jetzt wird es n bisschen 

927
00:44:19,320 --> 00:44:22,440
quer kann ich auch wieder mit 
Instanzen arbeiten von anderen 

928
00:44:22,440 --> 00:44:27,280
Klassen ne und ich kann zum 
Beispiel sagen ich kreiere die 

929
00:44:27,760 --> 00:44:31,000
dann, dann bin ich quasi auch. 
Also ich kann quasi ja auch 

930
00:44:31,000 --> 00:44:33,440
dieses New, was ich vorher 
gesagt hab, das kann quasi auch 

931
00:44:33,440 --> 00:44:35,200
in der Klasse funktionieren in 
der Instanz. 

932
00:44:35,200 --> 00:44:38,360
Ja und ich hol mir ne neue 
Klasse Mathe oder ich hol mir 

933
00:44:38,360 --> 00:44:40,560
einfach nur ne Referenz rein von
einer die es vorher gab. 

934
00:44:40,560 --> 00:44:43,040
Ja das macht man zum Beispiel 
oft, man kann zum Beispiel sagen

935
00:44:43,040 --> 00:44:47,440
im Konstruktoraufruf von der 
Statistics bekomme ich schon 

936
00:44:47,920 --> 00:44:51,840
eine Instanz der Matheklasse 
mit, dann hab ich eine 

937
00:44:51,840 --> 00:44:53,680
Matheklasse, das ist der große 
Unterschied, entweder. 

938
00:44:54,000 --> 00:44:58,080
Bin ich eine Matheklasse, dann 
hab ich sie geerbt oder ich hab 

939
00:44:58,080 --> 00:45:00,360
eine Matheklasse. 
Dann hab ich dann hab ich so ne 

940
00:45:00,360 --> 00:45:02,400
Instanz von so einer Matheklasse
wie auch immer die aussieht in 

941
00:45:02,400 --> 00:45:04,880
der Hand. 
Ja und jetzt ruf ich quasi 

942
00:45:04,880 --> 00:45:09,080
einfach wieder maß Punkt und 
jetzt ruf ich quasi nur diese 

943
00:45:09,080 --> 00:45:11,680
Funktion auf, die ich gerade 
brauche für meine Statistiks ja 

944
00:45:12,240 --> 00:45:14,720
und das können dann quasi in 
meiner Statistikklasse andere 

945
00:45:14,720 --> 00:45:17,440
sein als zum Beispiel jetzt in 
dieser Bildverarbeitungsklasse, 

946
00:45:17,440 --> 00:45:18,920
die ich vorher hatte, da brauch 
ich vielleicht andere 

947
00:45:18,920 --> 00:45:23,040
mathefunktionen ne für den. 
Endanwender jetzt aber von 

948
00:45:23,040 --> 00:45:25,760
meiner Statistikklasse sieht die
Sache viel sauberer aus, weil 

949
00:45:25,760 --> 00:45:27,840
wenn der sich jetzt anguckt 
Geräte mir noch mal bei deinem 

950
00:45:27,840 --> 00:45:30,160
Fall ne wo du im IDE bist und du
gehst jetzt auf die 

951
00:45:30,160 --> 00:45:32,200
Statistikklasse und drückst 
jetzt Punkt und jetzt kommt das 

952
00:45:32,200 --> 00:45:34,520
Autocomplete. 
Ja wenn ich jetzt die 

953
00:45:34,520 --> 00:45:37,200
Matheklasse komponiert habe, 
dann hab ich das ja privat 

954
00:45:37,200 --> 00:45:40,640
gemacht, dann hab ich jetzt ganz
sauber nur die Interfaces, also 

955
00:45:40,640 --> 00:45:43,800
nur die Funktionen die jetzt für
meine Statistikklasse relevant 

956
00:45:43,800 --> 00:45:46,040
sind und die erwarte ich ja 
quasi auch als Entwickler, wenn 

957
00:45:46,040 --> 00:45:47,760
ich die Statistikklasse benutze,
ja. 

958
00:45:48,400 --> 00:45:50,800
Was ich aber nicht habe, es sind
die ganzen Mathe raffel 

959
00:45:50,800 --> 00:45:52,680
Funktionen will ich ja auch 
nicht aufrufen wenn ich 

960
00:45:52,680 --> 00:45:55,160
statistics habe habe ich die 
aber geerbt, die Matheklasse ja 

961
00:45:55,160 --> 00:45:57,280
dann drücke ich wenn ich auf 
Punkt auf ne Idee drücke, dann 

962
00:45:57,280 --> 00:46:00,320
sehe ich alle Funktionen ja auch
die von der Matheklasse und die 

963
00:46:00,320 --> 00:46:03,920
von der Statistics Klasse, das 
heißt das Enkapsulieren 

964
00:46:04,480 --> 00:46:07,160
funktioniert noch viel 
effizienter wenn ich gar nicht 

965
00:46:07,160 --> 00:46:10,200
so viel Erbe oder wenn ich nur 
selten Erbe, dann wenn ich es 

966
00:46:10,200 --> 00:46:12,400
wirklich wenn wirklich auch alle
Funktionen die ich Erbe sehr 

967
00:46:12,400 --> 00:46:15,120
relevant sind für meine eigene 
Funktionalität, ja auch für den 

968
00:46:15,120 --> 00:46:18,400
Nutzer der mich benutzt ja. 
Und wenn das aber nicht so ist, 

969
00:46:18,400 --> 00:46:22,160
dann dann hab ich quasi trotzdem
eng kapseliert und Zugriff auf 

970
00:46:22,240 --> 00:46:24,240
gekapselte Funktion von der 
anderen Klasse. 

971
00:46:24,560 --> 00:46:27,520
Aber Schütte das quasi nicht in 
mein Public Interface rein. 

972
00:46:27,520 --> 00:46:31,040
Ja bleibt halt sauber versteckt.
Ja stellt sich heraus, dass das 

973
00:46:31,040 --> 00:46:32,720
irgendwie andauernd benutzt 
wird, ja. 

974
00:46:33,120 --> 00:46:34,440
Das sieht ja viel, viel 
sinnvoller. 

975
00:46:34,440 --> 00:46:37,720
Ja, also ich hab ja viel weniger
Kram, den ich einfach nicht 

976
00:46:37,720 --> 00:46:41,400
brauche dabei letzten Endes und 
auch schon vorübersichtlichkeit 

977
00:46:41,400 --> 00:46:44,000
dann irgendwie. 
Stimmt ja, wenn man sich es ganz

978
00:46:44,000 --> 00:46:46,920
genau anguckt, gibt es ja und es
gibt. 

979
00:46:47,200 --> 00:46:50,160
Pro und Contra für beides. 
Aber die Daumenregel ist im 

980
00:46:50,160 --> 00:46:51,160
Schnitt. 
Guck mal ob du das mit 

981
00:46:51,160 --> 00:46:53,960
Composition machen kannst da 
weil wenn man anfängt mit diesem

982
00:46:53,960 --> 00:46:56,640
ganzen Kram ist es total 
schwierig, man hat noch kein 

983
00:46:56,640 --> 00:46:59,920
Gefühl wie wann nehm ich was und
wie muss ich das machen. 

984
00:47:00,480 --> 00:47:02,400
Das ist also gerade für 
juniorige Entwickler im 

985
00:47:02,400 --> 00:47:05,000
objektorientierten Programmieren
ist ist gar nicht so einfach 

986
00:47:05,000 --> 00:47:08,400
rauszufühlen was mach ich hier 
am besten wie das ist so man 

987
00:47:08,400 --> 00:47:11,040
kann es echt vergleichen mit 
einer normalen Architektur, man 

988
00:47:11,040 --> 00:47:13,160
muss n bisschen Erfahrung haben,
man muss n bisschen was gesehen 

989
00:47:13,160 --> 00:47:16,560
und gemacht haben bis man rafft 
wie trenn ich das am besten auf 

990
00:47:16,560 --> 00:47:19,040
so ja. 
Ich will mal gerade noch ein 

991
00:47:19,040 --> 00:47:21,440
Beispiel aus dem Leben geben, da
kann man sich das Mal vorstellen

992
00:47:21,440 --> 00:47:24,080
mit diesen ganzen Haritans und 
diesen ganzen Patterns. 

993
00:47:24,080 --> 00:47:26,480
Ja, wir nehmen jetzt mal 1 aus 
unserem Leben, sagen wir mal, 

994
00:47:26,480 --> 00:47:30,120
wir haben ne, wir widerspiegeln 
ne ne ne Industrieunternehmen ne

995
00:47:30,120 --> 00:47:33,280
Factory, ja und dann könnten wir
zum Beispiel sagen wir haben ne 

996
00:47:33,280 --> 00:47:37,040
ne ne Klasse, die heißt Factory 
und da sind so Methoden drin wo 

997
00:47:37,040 --> 00:47:39,440
da steht erstmal die Firma drin 
wie heiße ich und so weiter wie 

998
00:47:39,440 --> 00:47:41,280
groß bin ich, wieviel 
Quadratmeter oder was weiß ich 

999
00:47:41,280 --> 00:47:44,400
so keine Ahnung ja und dann 
könnte es sowas geben wie ne 

1000
00:47:44,400 --> 00:47:47,680
Production line. 
Weil ich, was ich, was ich jetzt

1001
00:47:47,680 --> 00:47:50,240
im Code aufbauen will, ich will 
quasi, ich will quasi Factory 

1002
00:47:50,240 --> 00:47:52,480
irgendwie managen können, ne, 
aber grundsätzlich schreib ich 

1003
00:47:52,480 --> 00:47:54,960
ja nur ich schreib das ja nicht 
für jede einzelne Factory will 

1004
00:47:54,960 --> 00:47:57,520
ich jetzt n Code machen, sondern
für alle Factory also hab ich ne

1005
00:47:57,520 --> 00:48:00,480
klasse Factory wo ich erstmal so
grundsätzliche Daten speichern 

1006
00:48:00,480 --> 00:48:02,960
kann, dann könnte ich ne Klasse 
haben die heißt Production Lion 

1007
00:48:03,520 --> 00:48:08,080
und jetzt kann ich sagen ne 
Factory hat Production Lines 

1008
00:48:08,400 --> 00:48:11,120
also der Factory gehören die 
Production Lines ja die man man 

1009
00:48:11,120 --> 00:48:13,280
sagt das ist jetzt ne 
Komposition ne das heißt. 

1010
00:48:13,520 --> 00:48:16,320
Würde ne Instanz einer 
Production Line in die Instanz 

1011
00:48:16,320 --> 00:48:20,000
der Klasse Factory einklemmen? 
Ja, und dabei kann ich jetzt 

1012
00:48:20,000 --> 00:48:22,960
sogar noch sagen, das können ja 
mehrere sein, das ist auch das 

1013
00:48:22,960 --> 00:48:27,520
schicke, ja, ich kann sagen eine
Factory Instanz hat jetzt 

1014
00:48:27,760 --> 00:48:30,360
mehrere Instanzen 
unterschiedlich konfiguriert von

1015
00:48:30,360 --> 00:48:35,200
Production Lines ja 12357 ja und
so weiter und er nennt es jetzt 

1016
00:48:35,200 --> 00:48:37,840
eine Owens composition, weil die
Production line. 

1017
00:48:39,440 --> 00:48:41,040
Für sich alleine macht keinen 
Sinn. 

1018
00:48:41,080 --> 00:48:43,600
Ja, Production Line alleine lebt
nicht ohne Factory. 

1019
00:48:43,600 --> 00:48:47,800
Jetzt kommt das zweite Beispiel,
die Production Line nutzt 

1020
00:48:47,800 --> 00:48:51,080
Maschinen ja und jetzt auch 
wieder ich könnte ne Maschine ne

1021
00:48:51,080 --> 00:48:53,920
Presse haben, ich könnte ne CNC 
Maschine haben, ich könnte so n 

1022
00:48:53,920 --> 00:48:57,800
so n so n so n so n Laufband 
haben und so weiter ja die 

1023
00:48:57,800 --> 00:49:00,760
Maschinen aber sind jetzt anders
komponiert und das hat das mit 

1024
00:49:00,760 --> 00:49:02,920
der Lifetime jetzt zu tun, das 
ist noch mal was ich sagen will 

1025
00:49:02,920 --> 00:49:04,800
zu diesen Patterns dann brechen 
wir das dann auch ab an der 

1026
00:49:04,800 --> 00:49:08,080
Stelle aber so ne Maschine kann 
ja ganz alleine stehen ja. 

1027
00:49:08,320 --> 00:49:11,000
Die braucht keine, die braucht 
weder die Factory noch die 

1028
00:49:11,000 --> 00:49:13,080
Production Line. 
So richtig kannst du irgendwo 

1029
00:49:13,080 --> 00:49:15,040
hinstellen, kann er noch 
irgendwo gebaut worden sein und 

1030
00:49:15,040 --> 00:49:18,840
so weiter so und deswegen hat 
die Production Line nutzt eine 

1031
00:49:18,840 --> 00:49:23,200
Maschine, also der Lebenszyklus 
von der Maschine, der wird nicht

1032
00:49:23,200 --> 00:49:26,240
von der Production Line 
bestimmt, die Production Line 

1033
00:49:26,240 --> 00:49:29,200
wird nicht die Maschine 
instanzieren ja, denn das ist 

1034
00:49:29,200 --> 00:49:31,680
auch noch das komplexe Gerät bei
dem Ganzen den ganzen Kram, weil

1035
00:49:31,680 --> 00:49:34,560
ich hab ja gesagt und das kommt 
immer nicht vor, das mag ich 

1036
00:49:34,560 --> 00:49:36,160
nicht so, das kommt immer nicht 
vorbei diesen. 

1037
00:49:36,440 --> 00:49:39,360
Wenn man das so liest von außen,
ja, es kommt nie das Wort 

1038
00:49:39,360 --> 00:49:42,000
Lebenszyklus vor. 
Ich würde diesen 4 Pillars, wie 

1039
00:49:42,000 --> 00:49:45,160
sie immer so heißen, Abstraction
encapculation, Harritons and 

1040
00:49:45,160 --> 00:49:47,760
polymorphism, den würd ich auf 
jeden Fall n fünften dazu geben 

1041
00:49:47,760 --> 00:49:49,240
und den würd ich weiter nach 
oben schieben von der 

1042
00:49:49,240 --> 00:49:55,600
Wichtigkeit, das ist Lifecycle 
ja denn so n Objekt lebt also ne

1043
00:49:55,600 --> 00:49:59,480
Funktion nicht ne Funktion rufst
du auf, die arbeitet ab und gibt

1044
00:49:59,480 --> 00:50:02,280
dir n Return wert, die speichert
ja auch keine Daten zwischen die

1045
00:50:02,280 --> 00:50:03,840
sind dann verloren ja alles 
bleibt. 

1046
00:50:04,240 --> 00:50:07,600
Lokal in dieser Funktion aber so
ne Instanz lebt halt und da hat 

1047
00:50:07,600 --> 00:50:10,480
n Start n State wie man sagt 
über die Lebenszeit auch 

1048
00:50:10,480 --> 00:50:13,440
verändert werden kann und 
irgendjemand muss das 

1049
00:50:13,440 --> 00:50:16,720
Konstruieren, das Vieh, ja und 
irgendwer wird es auch 

1050
00:50:16,720 --> 00:50:18,560
destruieren und da, wenn es 
nicht mehr gebraucht wird 

1051
00:50:18,560 --> 00:50:22,560
weggeschmissen, ja und man muss 
sich halt überlegen, wenn man 

1052
00:50:22,560 --> 00:50:25,240
jetzt, wenn es alles in Klassen 
und Objekten sind was so moderne

1053
00:50:25,240 --> 00:50:27,920
Software ist, ja, da gibt es 
nichts anderes mehr, es gibt 

1054
00:50:27,920 --> 00:50:30,440
keinen freien Code mehr, es gibt
alles in Klassen und Objekten 

1055
00:50:30,440 --> 00:50:32,800
abgehandelt, ja. 
Da muss man sich halt auch 

1056
00:50:32,800 --> 00:50:35,760
überlegen, welche Instanz 
erzeugt welche andere, also wem 

1057
00:50:35,760 --> 00:50:38,720
gehört da wer und wer, wer sorgt
dafür, dass es wieder weg ist 

1058
00:50:38,720 --> 00:50:42,400
und so weiter ja, denn es kann 
ja auch, es können ja Sachen 

1059
00:50:42,400 --> 00:50:44,160
auch kommen und gehen in so 
einer Runtime. 

1060
00:50:44,160 --> 00:50:46,320
Ja du musst da auch dich darum 
kümmern, dass es wieder abgebaut

1061
00:50:46,320 --> 00:50:49,040
wird und nicht irgendwo rumeiert
und so weiter ja das das ist 

1062
00:50:49,040 --> 00:50:51,920
relativ komplex, ja. 
Das klingt furchtbar komplex, 

1063
00:50:51,920 --> 00:50:54,720
irgendwie so aber. 
Das ist makaber, komplex sogar. 

1064
00:50:54,720 --> 00:50:57,640
Ja, und es gibt extra, das ist 
auch noch was, es gibt sogar 

1065
00:50:57,640 --> 00:50:59,840
dann, um, um das irgendwie mal 
aufzumalen. 

1066
00:51:00,920 --> 00:51:03,040
Und das Schwierige ist ja auch 
noch, dass es ne, dass es 2 

1067
00:51:03,040 --> 00:51:04,640
Lebenszeiten gibt. 
Wenn du das jetzt Code 

1068
00:51:04,640 --> 00:51:07,360
hinschreibst, dann gibt es ja 
quasi das Bild von dem, wie du 

1069
00:51:07,360 --> 00:51:10,880
es aufgebaut hast und dann zur 
Runtime, das muss man sich dann 

1070
00:51:10,880 --> 00:51:13,560
im Kopf vorstellen, dann wird ja
quasi Leben eingehaucht und 

1071
00:51:13,560 --> 00:51:15,720
existieren viele Varianten von 
diesen Dingern, die sind 

1072
00:51:15,720 --> 00:51:18,240
irgendwie verwoben. 
Ne, das ist komplizierter als ne

1073
00:51:18,240 --> 00:51:20,240
relationale Datenbank was da 
alles passiert. 

1074
00:51:20,240 --> 00:51:24,960
Ja und da gibt es ne Sprache, 
die heißt UML Unified Markup 

1075
00:51:24,960 --> 00:51:27,600
Language. 
Da kann man das quasi mal 

1076
00:51:27,600 --> 00:51:30,280
aufmalen. 
Wieso Klassenzugehörigkeiten 

1077
00:51:30,280 --> 00:51:31,880
sind das sind, das hat 
vielleicht unsere Zuhörer schon 

1078
00:51:31,880 --> 00:51:34,120
mal gesehen, da sind so boxen 
und dann, so gibt es so Pfeile 

1079
00:51:34,120 --> 00:51:36,080
mit verschiedenen, und das ist 
ganz wichtig, was wir mal 

1080
00:51:36,080 --> 00:51:39,640
angucken, sind die Pfeile 
ausgefüllt oder sind die ool und

1081
00:51:39,640 --> 00:51:41,960
fangen die an mit einer Raute 
oder nicht und so weiter und da 

1082
00:51:41,960 --> 00:51:44,800
gibt es, ich will das Mal 
andeuten, da, da wird das quasi 

1083
00:51:44,800 --> 00:51:47,120
alles ausgedrückt, ob irgendwas 
voneinander erbt oder ob 

1084
00:51:47,120 --> 00:51:50,560
irgendjemand jemanden hat oder 
ob jemanden den Life, den Life 

1085
00:51:50,560 --> 00:51:52,560
Cycle von jemandem bestimmt oder
nicht und so weiter. 

1086
00:51:52,960 --> 00:51:55,360
Da kann man so n Fettes UML 
Diagramm zeichnen von seinem 

1087
00:51:55,360 --> 00:51:59,080
ganzen Code ja oder zeichnen 
lassen oder so weiß ich nicht. 

1088
00:51:59,080 --> 00:52:01,200
Ja dann sieht dann dann merkt 
man manchmal, wenn man sich das 

1089
00:52:01,200 --> 00:52:03,600
Aufmalt irgendwie wie komplex 
der ganze Kram ist oder ja o. 

1090
00:52:04,000 --> 00:52:05,800
K kann man wahrscheinlich schon 
sich irgendwie auch erstellen 

1091
00:52:05,800 --> 00:52:07,440
lassen mit irgendwelchen Tools. 
Nein kannst. 

1092
00:52:07,440 --> 00:52:08,880
Du, die mittlerweile auch 
erstellen lassen? 

1093
00:52:08,880 --> 00:52:10,640
Ja genau. 
Aber jetzt, du hattest jetzt 

1094
00:52:10,640 --> 00:52:14,200
noch das Poly Morphism erwähnt, 
aber bist natürlich drauf 

1095
00:52:14,200 --> 00:52:16,560
eingegangen, ne? 
Ja, das Poly Morphism ist. 

1096
00:52:16,560 --> 00:52:18,880
Ich benutz das zum Beispiel 
selber gar nicht so oft. 

1097
00:52:19,120 --> 00:52:21,480
Das ist so n bisschen. 
Ach das, das kommt so n 

1098
00:52:21,480 --> 00:52:25,360
bisschen. 
Aus der Sucht danach, dass man 

1099
00:52:25,680 --> 00:52:28,000
also in diesen kompilierten 
Sprachen wie Java und C plus 

1100
00:52:28,000 --> 00:52:31,600
Plus, da hast du immer 
Schwierigkeiten, überhaupt auch 

1101
00:52:32,400 --> 00:52:36,240
mit Code teilen innerhalb deiner
eigenen Software zu sprechen. 

1102
00:52:36,240 --> 00:52:40,000
Ja, und das gleich zu ziehen, 
ja, also Polymorphism heißt 

1103
00:52:40,000 --> 00:52:41,920
halt, dass bei der gleichen 
Funktion. 

1104
00:52:43,000 --> 00:52:46,080
Verschiedene Ergebnisse 
rauskommen, je nachdem, wer du 

1105
00:52:46,080 --> 00:52:48,600
bist als geerbte Funktion. 
Ich mach das jetzt noch mal an 

1106
00:52:48,600 --> 00:52:52,000
diesem blöden Beispiel, Animal 
und und und und Dog und Cat und 

1107
00:52:52,000 --> 00:52:54,400
so weiter klar ja, das ist 
nämlich dieses Beispiel was 

1108
00:52:54,400 --> 00:52:56,960
immer kommt. 
Also du hast in der Animal Class

1109
00:52:56,960 --> 00:53:00,680
hast du zum Beispiel genau diese
Funktion, irgendwie Sound oder 

1110
00:53:00,680 --> 00:53:04,120
Irgendsowas, also das 
Tiergeräusch ja und du willst 

1111
00:53:04,120 --> 00:53:09,280
später, wenn du irgendwer macht 
für dich diese Animals ja und 

1112
00:53:09,280 --> 00:53:11,600
der macht aber nicht n Animal 
sondern der macht ne Cat. 

1113
00:53:12,240 --> 00:53:16,360
Und er macht nen Dog und er 
macht nen Fisch oder irgend 

1114
00:53:16,360 --> 00:53:19,960
sowas. 
Ja und aber in also auf der 

1115
00:53:19,960 --> 00:53:23,680
Abstraktionsebene hältst du aber
eigentlich nur n Animal in der 

1116
00:53:23,680 --> 00:53:25,760
Hand. 
Dich interessiert jetzt in 

1117
00:53:25,760 --> 00:53:27,840
diesem Stück auf der 
Abstraktionsleihe wo du gerade 

1118
00:53:27,840 --> 00:53:31,200
bist nur das Animal und dann 
hast du die Funktion Sound, das 

1119
00:53:31,200 --> 00:53:32,960
ist dein Interface, das wurde 
dir versprochen. 

1120
00:53:32,960 --> 00:53:35,800
Ja Sound gibt es ja, weil auf 
der Base Class Animal gibt es 

1121
00:53:35,800 --> 00:53:40,000
halt die Funktion Sound ja so 
und je nachdem was du jetzt 

1122
00:53:40,000 --> 00:53:41,600
gerade in die Hand bekommen 
hast. 

1123
00:53:42,640 --> 00:53:46,440
Macht halt Sound entweder Miau 
oder Bark oder blub, blub oder 

1124
00:53:46,440 --> 00:53:49,560
irgend so was für den Fisch so 
ja das ist ein ganz bescheuertes

1125
00:53:49,560 --> 00:53:51,720
Beispiel, weil das weil man 
kriegt es nicht, also ich kriege

1126
00:53:51,720 --> 00:53:53,920
selber nicht im Kopf irgendwie 
auf irgendwas sinnvolles mit dem

1127
00:53:53,920 --> 00:53:55,920
Kot gebügelt. 
So und deswegen ist mir gerade 

1128
00:53:55,920 --> 00:53:57,520
während ich das erzählt hab, hab
ich überlegt gibt es ein 

1129
00:53:57,520 --> 00:53:59,840
besseres Beispiel, ich sag 1 aus
unserer Welt. 

1130
00:54:00,440 --> 00:54:02,400
Wir haben zum Beispiel, Wir 
haben ja diese Low Code 

1131
00:54:02,400 --> 00:54:03,600
Anwendung geredet, weißt du ja 
ne. 

1132
00:54:03,760 --> 00:54:05,160
Und du hast das hab ich schon 
mal gehört. 

1133
00:54:05,280 --> 00:54:08,160
Ja genau, also ja, das ist schön
so. 

1134
00:54:08,160 --> 00:54:10,320
Und dann, wir können ja unsere 
Nutzer haben ja diesen Frontend 

1135
00:54:10,320 --> 00:54:12,800
Bilder da und die ziehen, die 
ziehen da ja irgendwie Buttons 

1136
00:54:12,800 --> 00:54:16,480
drauf und ne Form und Datagrid 
und n Icon oder was weiß ich so 

1137
00:54:16,480 --> 00:54:21,520
ja so und bei mir ist das alles 
n Widget also diese Dinger sind 

1138
00:54:21,520 --> 00:54:25,120
von der von der Basisklasse her 
mal ein verdammtes Widget, ja. 

1139
00:54:25,800 --> 00:54:28,720
So, und was die alle können 
müssen und was ich auch können 

1140
00:54:28,720 --> 00:54:30,720
muss im Code, ich muss an 
irgendeiner Stelle im Code, das 

1141
00:54:30,720 --> 00:54:32,360
ist sehr hoch am 
abstraktionslevel muss ich jetzt

1142
00:54:32,360 --> 00:54:35,040
sagen, so pass mal auf, jetzt 
render ich diese ganze Seite hin

1143
00:54:35,600 --> 00:54:38,360
ja also muss ich sagen für alle 
Widgets ja Ruf auf die 

1144
00:54:38,360 --> 00:54:43,240
Renderfunktion ja, dabei ist mir
völlig wurst was das jetzt 

1145
00:54:43,240 --> 00:54:45,120
rendert. 
Ja an der Stelle ich will nur 

1146
00:54:45,120 --> 00:54:47,080
erst ich muss dir irgendwo mal 
muss ich ja mal die Anweisung 

1147
00:54:47,080 --> 00:54:50,640
geben, rendert jetzt mal alle 
durch ja und dann nimmt er die 

1148
00:54:50,640 --> 00:54:52,920
nächste Page in die Hand gehst 
du auf die nächste Page, dann 

1149
00:54:53,120 --> 00:54:54,720
musst du ja wieder alle rendern 
ja. 

1150
00:54:55,080 --> 00:54:57,920
Da hab ich also so ne Art vor 
Loop für alle Widgets, die auf 

1151
00:54:57,920 --> 00:55:00,160
dieser Page sichtbar sein 
sollen. 

1152
00:55:00,960 --> 00:55:03,800
Widget, Punkt, Render, Widget, 
Punkt, Render, Widget, Punkt, 

1153
00:55:03,800 --> 00:55:05,760
Render, Widget, Punkt, Render 
und diese Widgets sind alles 

1154
00:55:05,760 --> 00:55:09,840
verschiedene Klassen von der 
basisklasse Widget, aber 

1155
00:55:09,840 --> 00:55:13,840
tatsächlich ist es n Button n 
datagrid Form oder Irgendsowas 

1156
00:55:13,840 --> 00:55:17,480
ja und aber das Widget sagt Es 
gibt hier ne Funktion Render und

1157
00:55:17,480 --> 00:55:19,760
ihr habt die alle zu 
implementieren Render ja. 

1158
00:55:20,000 --> 00:55:22,320
Und das Render auf dem Button 
Rendert mir halt n Button und 

1159
00:55:22,320 --> 00:55:24,560
das die Renderfunktion auf dem 
Form, die rendert halt das was 

1160
00:55:24,560 --> 00:55:27,640
ne Form sein soll hin. 
Ja so und deswegen ist das 

1161
00:55:27,640 --> 00:55:31,840
sinnvoll weil du musst im Code 
ganz oft auf einer sehr hohen 

1162
00:55:31,840 --> 00:55:38,000
Abstraktionsebene mit Objekten 
umgehen weißt du so ich ich ich 

1163
00:55:38,000 --> 00:55:41,680
ich ich weiß an der Stelle gar 
nicht an der Stelle wo ich im 

1164
00:55:41,680 --> 00:55:44,480
Code bin geht es nur darum den 
Scheiß einmal runter zu rendern,

1165
00:55:44,480 --> 00:55:46,600
ja da da interessiert mich das 
aber nicht was das ist. 

1166
00:55:46,880 --> 00:55:49,200
Und, und wer das gemacht wurde, 
das passiert zu einem anderen 

1167
00:55:49,200 --> 00:55:50,400
Zeitpunkt. 
Wenn du nämlich Gerrit, das 

1168
00:55:50,400 --> 00:55:51,920
kannst du jetzt auch noch 
vorstellen, wenn du nämlich da 

1169
00:55:51,920 --> 00:55:54,160
jetzt zum Beispiel einen neuen 
Button ziehen willst, dann 

1170
00:55:54,160 --> 00:55:58,960
drückst du ja oben auch bei dem 
Auswahl Drop Down auf Button und

1171
00:55:58,960 --> 00:56:01,280
dann klickst du noch mal in das 
Frontend, dann wird jetzt ein 

1172
00:56:01,280 --> 00:56:06,000
Button hergestellt, an der 
Stelle kreierst du eine Instanz 

1173
00:56:06,000 --> 00:56:08,400
von der Klasse Widget, die aber 
Button ist und das ist 

1174
00:56:08,400 --> 00:56:11,360
Polymorphese mehr. 
Und jetzt vereinheitlicht das 

1175
00:56:11,360 --> 00:56:13,600
Interface. 
Und jetzt, wenn wenn jetzt unser

1176
00:56:13,600 --> 00:56:15,760
neuer Entwickler zum Beispiel 
nicht einen Button machen muss, 

1177
00:56:15,760 --> 00:56:18,160
sondern was weiß ich einen centi
Chart oder irgendwas, dann sage 

1178
00:56:18,240 --> 00:56:20,240
ich ihm, pass mal auf, wenn du 
einen centi Chart machst. 

1179
00:56:20,320 --> 00:56:23,280
Hier guckst du mal Widget, das 
sind die Base Funktionen, die 

1180
00:56:23,280 --> 00:56:25,840
musst du alle implementieren und
wenn du die sauber implementiert

1181
00:56:25,840 --> 00:56:28,200
hast, dann ist schon fertig, 
dann funktioniert schon der 

1182
00:56:28,200 --> 00:56:31,760
restliche Code ja weil der 
einfach nur diese dieses 

1183
00:56:31,760 --> 00:56:35,040
Interface quasi ausführt und 
wenn du das ordentlich gemacht 

1184
00:56:35,040 --> 00:56:38,040
hat funktioniert es einfach. 
Ist n besseres Beispiel als die 

1185
00:56:38,040 --> 00:56:40,040
blöde Runde Katzen. 
Ja, jetzt musst du mir aber 

1186
00:56:40,040 --> 00:56:41,920
zwischendurch auch mal n Satz 
sagen lassen, um das mal so 

1187
00:56:41,920 --> 00:56:44,560
halbwegs versuchen zu 
rekapitulieren, ja, ist das 

1188
00:56:44,560 --> 00:56:47,280
quasi unmöglich als als nicht 
Softwareentwickler. 

1189
00:56:47,360 --> 00:56:49,720
Ich hab auch quasi wieder 
vergessen was ich sagen wollte, 

1190
00:56:49,720 --> 00:56:51,920
aber ist Grad der Groschen 
gefallen als du mit dem Brennern

1191
00:56:51,920 --> 00:56:56,000
kamst und du sagtest, dass 
Methoden, also unterschiedlich 

1192
00:56:56,000 --> 00:56:59,040
sich verhalten können, letzten 
Endes, je nachdem wo sie oder 

1193
00:56:59,040 --> 00:57:02,400
wie sie aufgerufen werden oder 
in welchem Kontext und rendern 

1194
00:57:02,400 --> 00:57:04,720
hast du jetzt genommen, weil der
eine Rendert Halt n Button hin 

1195
00:57:04,720 --> 00:57:06,400
und das nächste Rendert ne 
Tabelle hin. 

1196
00:57:06,880 --> 00:57:08,960
Und das nächste Render hat 
irgendwie n Chart hin, aber es 

1197
00:57:08,960 --> 00:57:12,400
ist immer die Funktion render. 
Genau mehr hab ich nicht zu 

1198
00:57:12,400 --> 00:57:14,920
sagen. 
Ja, das ist auch nicht das 

1199
00:57:14,920 --> 00:57:17,040
Thema, wo man in so ne riesen 
Diskussion kommen kann, wo man 

1200
00:57:17,040 --> 00:57:19,040
das eigentlich ist das so ne 
Erklärbeerfolge heute. 

1201
00:57:19,680 --> 00:57:21,600
Also ich kürz das mal ab, wir 
haben schon n bisschen länger 

1202
00:57:21,600 --> 00:57:24,560
gesprochen, also versuchen noch 
mal so ne Summary zu machen, 

1203
00:57:24,560 --> 00:57:26,800
also dieses ganze 
objektorientierte programmieren,

1204
00:57:26,800 --> 00:57:31,760
das ist im Prinzip ja ne Idee 
wie Entwickler selber ihren Code

1205
00:57:32,160 --> 00:57:36,240
so strukturieren können. 
Dass er krass wiederverwendbar 

1206
00:57:36,240 --> 00:57:44,040
wird und einfach zu durchsehen 
und zu verstehen auch für vor 

1207
00:57:44,040 --> 00:57:47,000
allen Dingen andere Nutzer, also
für einen selbst sowieso, ist es

1208
00:57:47,000 --> 00:57:50,240
auch mal gut, wenn man sich 
selber organisiert, aber und 

1209
00:57:50,240 --> 00:57:51,400
und. 
Und das vielleicht noch mal 

1210
00:57:51,400 --> 00:57:53,840
gesagt an der Stelle, unsere 
haben ja auch oft schon gesagt, 

1211
00:57:53,840 --> 00:57:56,920
Open Source, Bibliotheken und so
weiter und sofort, ja, was sind 

1212
00:57:56,920 --> 00:58:00,200
denn softwarebibliotheken? 
Bibliotheken sind Anhäufungen 

1213
00:58:00,200 --> 00:58:02,560
von genau diesen Klassen. 
Ja, die Methoden haben, die 

1214
00:58:02,560 --> 00:58:04,080
irgendwas beschreiben und sofort
ja. 

1215
00:58:04,720 --> 00:58:06,160
So wird das normalerweise 
gemacht. 

1216
00:58:06,160 --> 00:58:08,720
Ja, und dann, wenn ich ne 
Bibliothek benutzen will von 

1217
00:58:08,720 --> 00:58:11,200
jemandem, den ich gar nicht 
kenne, also der sie irgendwie 

1218
00:58:11,200 --> 00:58:14,200
geschrieben hat, will aber 
verstehen was los ist, hat sich 

1219
00:58:14,200 --> 00:58:16,560
herausgestellt, dass das 
objektorientierte Programmieren 

1220
00:58:16,560 --> 00:58:21,360
n cooler weg ist, um es relativ 
gut und relativ sicher in meinem

1221
00:58:21,360 --> 00:58:24,880
Code zu nutzen, ne? 
Und es schien mir jetzt auch 

1222
00:58:24,880 --> 00:58:28,880
sehr, ich weiß nicht, irgendwie 
realitätsnah zu sein oder sowas.

1223
00:58:28,880 --> 00:58:32,840
Also die ganzen Beispiele, die 
du jetzt so gemacht hast, außer 

1224
00:58:32,840 --> 00:58:36,160
das vielleicht mit den Tieren. 
Und ich erinnere mich einfach an

1225
00:58:36,160 --> 00:58:38,240
die Factory und die 
Productionline und so weiter 

1226
00:58:38,720 --> 00:58:41,280
wirkt ja so, als würde man 
versuchen irgendwelche echten 

1227
00:58:41,440 --> 00:58:43,760
Dinge realen Dinge auch 
abzubilden. 

1228
00:58:44,320 --> 00:58:46,400
In Klassen wiederum und 
Objekten. 

1229
00:58:46,880 --> 00:58:48,880
Ja, genau, möglicherweise ist 
die ja genau. 

1230
00:58:49,280 --> 00:58:52,520
Also es gibt ja so n Buzzword in
digitalen Zwillingen so, das ist

1231
00:58:52,560 --> 00:58:54,960
irgendwie so für die für die 
nicht Programmierer so ne, man 

1232
00:58:54,960 --> 00:58:57,280
sagt ja irgendwie, das ist die 
digitale Abbildung von der 

1233
00:58:57,280 --> 00:59:01,600
Maschine oder Irgendsowas. 
Das ist, wenn du so eine Klasse 

1234
00:59:01,600 --> 00:59:02,880
hast. 
Aber tatsächlich ist es 

1235
00:59:02,880 --> 00:59:06,640
andauernd so, dass Entwickler 
alle möglichen reellen Dinge mit

1236
00:59:06,640 --> 00:59:08,960
sehr guten Namen versehen und 
versuchen, die ganz das ganze 

1237
00:59:08,960 --> 00:59:11,280
reelle Problem was ich habe, was
ich an ne Software gießen 

1238
00:59:11,280 --> 00:59:15,360
möchte, genauso widerzuspiegeln.
Ja, das sind im Prinzip alles 

1239
00:59:15,360 --> 00:59:18,440
Mini digitale Zwillinge von 
Miniproblemen oder Aspekten von 

1240
00:59:18,440 --> 00:59:21,440
meinem Gesamtproblem was ich hab
und und der deren Beziehung 

1241
00:59:21,440 --> 00:59:24,000
untereinander widerspiegeln dann
hoffentlich halt auch die die 

1242
00:59:24,000 --> 00:59:26,840
Realitätsbeziehung hast du, ich 
hab bei der Factory re 

1243
00:59:26,840 --> 00:59:29,600
production nein gesagt. 
Also normalerweise musst du auch

1244
00:59:29,600 --> 00:59:31,560
deinen Code durchgehen können 
mit den ganzen Klassen, die du 

1245
00:59:31,560 --> 00:59:34,320
hast und diesen ganzen Patterns 
und den Vererbungen und und und 

1246
00:59:34,320 --> 00:59:38,640
Zusammenhängen und Relationen 
und musst dir das quasi vorsagen

1247
00:59:38,640 --> 00:59:41,440
können und es muss im besten 
Falle zur Realität passen, wenn 

1248
00:59:41,440 --> 00:59:44,520
es nicht zur Realität passt, 
dann hast du, dann hast du bei 

1249
00:59:44,520 --> 00:59:46,840
deinem objektorientierten Design
irgendwo n Fehler gemacht und 

1250
00:59:46,840 --> 00:59:49,920
der der tut dir meistens relativ
stark weh, dann irgendwann ne 

1251
00:59:49,920 --> 00:59:53,120
das das merkt man dann wenn man 
dann die Anwendung größer wird, 

1252
00:59:53,120 --> 00:59:55,200
ja. 
OK, dann noch mal von mir 

1253
00:59:55,200 --> 00:59:58,080
vielleicht letzte Frage, du hast
jetzt immer C plus plus erwähnt 

1254
00:59:58,080 --> 01:00:00,400
und Java glaub ich als als 
objektorientierte 

1255
01:00:00,400 --> 01:00:02,440
Programmiersprachen. 
Ich hab jetzt immer noch nicht 

1256
01:00:02,440 --> 01:00:04,960
so ganz verstanden was jetzt zum
Beispiel Node JS wäre oder oder 

1257
01:00:05,000 --> 01:00:07,920
Java Script du benutzt es ja 
auch so als also 

1258
01:00:07,920 --> 01:00:12,160
objektorientiert oder nicht. 
Ja, alle modernen Sprachen 

1259
01:00:12,560 --> 01:00:14,520
unterstützen Objektorientiertes 
programmieren. 

1260
01:00:14,520 --> 01:00:16,880
Punkt. 
OKOK du kannst damit auch 

1261
01:00:16,880 --> 01:00:20,800
objektorientiert programmieren. 
Ja, so der Unterschied ist, dass

1262
01:00:20,800 --> 01:00:23,040
das C plus plus ne kompilierte 
Sprache ist. 

1263
01:00:23,520 --> 01:00:26,720
Und zum Beispiel Python und Java
Script und so weiter sind 

1264
01:00:26,720 --> 01:00:30,640
interpretierte Sprachen. 
Du bist mit C plus plus noch in 

1265
01:00:30,640 --> 01:00:34,000
viel krasseren Gefängnissen 
unterwegs, was die Aufrufbarkeit

1266
01:00:34,000 --> 01:00:38,640
und die Interoperabilität von 
Funktionalität innerhalb deines 

1267
01:00:38,640 --> 01:00:41,360
Codes angeht. 
Deswegen ist in C plus plus das 

1268
01:00:41,360 --> 01:00:43,120
auch erstmal so richtig, 
deswegen war das auch ein 

1269
01:00:43,120 --> 01:00:46,120
Durchbrecher ja man, früher war 
es gar nicht so einfach 

1270
01:00:46,120 --> 01:00:49,040
irgendwie Code. 
Trocken also don't repeat 

1271
01:00:49,040 --> 01:00:50,880
yourself. 
Ja, also den Code so zu 

1272
01:00:50,880 --> 01:00:52,960
organisieren, dass ich ihn halt 
überall irgendwie wieder gut 

1273
01:00:52,960 --> 01:00:55,600
aufrufen kann. 
Ja, weil das das heißt ja, dass 

1274
01:00:55,600 --> 01:00:58,360
ich quasi Interfaces haben muss,
die sich wiederverwend 

1275
01:00:58,360 --> 01:01:00,680
Wiederverwendbarkeit heißt immer
ein gewisses Maß an 

1276
01:01:00,680 --> 01:01:05,600
Standardisierbarmachung ja, muss
ich ja erreichen, ja, und das 

1277
01:01:05,600 --> 01:01:08,000
ist gar nicht so einfach in 
diesen Strictly Type 

1278
01:01:08,000 --> 01:01:11,560
kompilierten languages wie C 
plus Plus und Java, es ist 

1279
01:01:11,560 --> 01:01:14,160
sowieso viel einfacher in Python
und Java Script, aber. 

1280
01:01:15,280 --> 01:01:17,360
Es wird auch genutzt. 
Objektorientierte Programmierung

1281
01:01:17,360 --> 01:01:18,440
und Python manchmal nicht so 
oft. 

1282
01:01:18,440 --> 01:01:20,760
Python hat manchmal einfach so n
Skript was runterläuft so das 

1283
01:01:20,760 --> 01:01:23,080
und dann dann weiß man auch 
schon, dass man es irgendwie gar

1284
01:01:23,080 --> 01:01:25,840
nicht so viel braucht, weil es 
relativ irgendwie tack, tack, 

1285
01:01:25,840 --> 01:01:29,440
tack, tack, Tack irgendwas 
abgehst ja führt ein Pfeilformat

1286
01:01:29,440 --> 01:01:31,440
in n anderes über, da brauchst 
du jetzt auch nicht riesen 

1287
01:01:31,680 --> 01:01:34,800
Objekte oder irgendwas basteln, 
ja sobald du irgendwie n 

1288
01:01:34,800 --> 01:01:37,560
bisschen mehr machst in der 
Anwendung so und merkst du 

1289
01:01:37,560 --> 01:01:39,480
sofort wenn du das nicht 
irgendwie aufteilst wenigstens 

1290
01:01:39,480 --> 01:01:42,560
in Funktionen so n bisschen. 
Aber viel besser noch gleich in 

1291
01:01:42,560 --> 01:01:45,240
in Klassen und so weiter da bist
du sofort verloren, weil du 

1292
01:01:45,240 --> 01:01:46,920
einfach spaghetticode dahin 
donnerst. 

1293
01:01:46,920 --> 01:01:49,280
Das ist nicht mehr erwartbar und
nicht mehr hinterhinbar. 

1294
01:01:51,120 --> 01:01:53,160
Ich glaube, das ist so ein 
Konzept, was auch nicht mehr 

1295
01:01:53,160 --> 01:01:55,200
umgeworfen wird gefühlt, man hat
das mal. 

1296
01:01:55,760 --> 01:01:59,080
Ich glaube, man hat da den 
Goldenen, die Goldene Goldene 

1297
01:01:59,080 --> 01:02:03,920
Mitte gefunden, ich glaube, 
alle, alle sehr großen oder 

1298
01:02:03,920 --> 01:02:07,040
mittelgroßen Anwendungen sind 
irgendwie objektorientiert 

1299
01:02:07,280 --> 01:02:09,200
programmiert, aufgeschrieben 
heutzutage. 

1300
01:02:10,320 --> 01:02:12,040
Im Detail nach 
Programmiersprache ändert sich 

1301
01:02:12,040 --> 01:02:14,040
das so n bisschen. 
Wie wie genau geht Vererbung? 

1302
01:02:14,040 --> 01:02:15,640
Kannst du von mehreren Vererben 
nicht so weiter da. 

1303
01:02:15,640 --> 01:02:18,160
Du kannst dir ja vorstellen, da 
gibt es zig theoretische 

1304
01:02:18,160 --> 01:02:19,480
Möglichkeiten wie du damit 
umgehen kannst. 

1305
01:02:19,480 --> 01:02:21,680
Die sind alle so n bisschen 
unterschiedlich, aber am Ende 

1306
01:02:22,080 --> 01:02:24,160
das objektorientierte 
Programmieren hat sich 

1307
01:02:24,160 --> 01:02:26,760
durchgesetzt. 
Über alle modernen Sprachen 

1308
01:02:26,760 --> 01:02:29,360
hinweg ist der Standardweg, 
deswegen muss man es einmal 

1309
01:02:29,360 --> 01:02:31,200
verstanden haben. 
Was ist ne klasse und was ist so

1310
01:02:31,200 --> 01:02:33,520
ne Instanz und was sind 
Instanzmethoden und 

1311
01:02:33,520 --> 01:02:35,400
klassenmethoden und so weiter so
deswegen würde ich einfach n 

1312
01:02:35,400 --> 01:02:37,520
bisschen durchgehen. 
Ja, mir hat das schon auch viel 

1313
01:02:37,520 --> 01:02:40,240
Background noch zu dem gegeben, 
zu unserem Lowcode, zu letzten 

1314
01:02:40,240 --> 01:02:43,880
Endes, wo, wo das ja auch 
Anwendung findet, also die 

1315
01:02:43,880 --> 01:02:48,000
Konzepte der objektorientierten 
Programmierung, ohne dass man 

1316
01:02:48,000 --> 01:02:50,360
programmieren muss. 
So wär das, hat sich das da mal 

1317
01:02:50,360 --> 01:02:51,520
anzugucken, kann das auch zu 
hören. 

1318
01:02:51,920 --> 01:02:54,640
Das hilft auf jeden Fall für für
alle diejenigen, die jetzt 

1319
01:02:54,640 --> 01:02:56,640
tatsächlich nichts weglassen, so
wie ich. 

1320
01:02:57,760 --> 01:03:01,280
OK, cool, Burkhard, gibt es da 
noch sonst was zum Thema OOP 

1321
01:03:01,520 --> 01:03:02,640
bestimmt noch ne ganze Menge, 
ne. 

1322
01:03:02,640 --> 01:03:04,560
Aber ja, ich glaube auch 
wahrscheinlich auch n paar 

1323
01:03:04,560 --> 01:03:06,040
Sachen vergessen. 
Da gibt es irgendwann noch mal 

1324
01:03:06,040 --> 01:03:08,360
ne Spezialfolge oder so. 
Ich glaube für den Moment haben 

1325
01:03:08,400 --> 01:03:11,040
wir haben wir ganz gut drüber 
gesprochen glaub ich passt. 

1326
01:03:11,040 --> 01:03:12,480
Gut, dann machen wir n Deckel 
drauf. 

1327
01:03:12,720 --> 01:03:14,960
Danke Burkhard und danke Euch 
fürs Zuhören. 

1328
01:03:14,960 --> 01:03:18,400
Tschüss von der Ostsee. 
Einfach komplex wird präsentiert

1329
01:03:18,400 --> 01:03:21,040
und produziert von Heiseware. 
Wir freuen uns auf deine Fragen 

1330
01:03:21,040 --> 01:03:23,680
und 
deinfeedbackanpodcasts@heiseware.com

1331
01:03:23,840 --> 01:03:26,400
vielen Dank fürs Hören dieser 
Folge bis Dienstag in 2 Wochen 

1332
01:03:26,400 --> 01:03:27,520
und Tschüss aus Hamburg.