Moin zufolge 82 von einfach komplex.
Hier spricht Gerrit und ich hab den Burkhard auch da.
Hallo Burkhard. Moin, nicht aus Hamburg mal
wieder von der Ostsee so n paar Folgen hatten wir hier schon mal
glaub ich oder Gerrit. Haben wir schon gemacht.
Ja, und wenn es heute raschelt und und rüttelt und knallt am
Mikrofon, dann liegt das daran, weil du es in der Hand.
Hast genau, ich fühl mich hier wieso n wie n Popsänger hier
gerade Mikro. Ich hab nämlich den blöden
Mikrofonständer vergessen und da hast du das Ding halt in der
Hand, ja. Nicht so schlimm.
Thematisch wird es ja relativ einfach sein heute für dich,
hast du gesagt, also OOP Object Oriental programming, ich glaube
letzte Woche deine Worte waren, das muss eigentlich jeder
Programmierer und jede Programmiererin aus dem Stegreif
einfach mal so drauf haben. Stimmt, das hab ich gesagt.
Ja, das ist so. Ja, hier ist auch meine Meinung.
Ja also OP ist glaub ich heute noch zentral.
Ja objektorientiertes programmieren ist das was man
schon drauf haben sollte, ja. Erfahren wir in dieser Folge
warum. Aber ich glaub das kann auch
jeder jeder über gute Programmierer kann das aus dem
Stegreif schießen, so was die wichtigsten Konzepte sind und
so, ja. Na ja, trotzdem wertvoll drüber
zu sprechen, weil wir haben auch schon, das hab ich jetzt
irgendwie häufig erwähnt, in allen möglichen Folgen OP und
wir haben das ja auch n bisschen bei unserem Produkt drinne, die
Konzepte davon, vielleicht sagst du dazu auch was, nachher weiß
ich nicht, auf jeden Fall interessiert es mich daher auch
und ich bin da ja auch schon in Berührung gekommen, obwohl ich
ja. Gar nicht Programmierer bin oder
Softwareentwickler? Dann lass doch mal loslegen mit
OOP, Object Oriental Programming und Du gibst uns wie immer mal n
kleinen Überblick zum Start. Was ist das eigentlich und was
gibt es da noch, vielleicht auch in Abgrenzung zu was nicht OOP
ist. Ja, genau so würde ich es
tatsächlich auch anfangen. So hab ich es n bisschen.
Ich hab ja mal wieder n Spicker gemacht, das ist immer
eigentlich ganz cool und der Spicker, der ist nie digital bei
mir, ich hab immer richtig so hier mit dem Kuli und so, das
find ich eigentlich gar nicht schlecht, aber der Spicker der
sagt. Fangen wir gar nicht bei
Objektorientiert an. Das ist nämlich erst Punkt 3.
In Punkt 1. Fangen wir erst mal anzugucken,
was gibt es überhaupt, also wo will ich überhaupt hin.
Objektorientiertes Programmieren ist ja ne Art Quellcode
aufzuschreiben, das ist es ja, und da gibt es halt noch
verschiedene Arten und ganz am Anfang oder die einfachste Art
ist die imperative Art, so heißt es ja Punkt 1, Imperativ ja, wir
müssen ja mal kurz einordnen, objektorientiertes programmieren
ist halt ne Art des Quellcodes aufschreibens hab ich gerade
schon gesagt und was ist Quellcode, es sind einfach die
Zeilen sind Instruktionen sind Programme.
Produktionen in Programmen ja, ich fang mal im Urstand noch mal
ganz kurz an. Ich kann natürlich Assembler
hinschreiben, das ist das das Maschinennase, darüber sprechen
wir nicht, wir sprechen schon über Source Code, aber wir
sprechen auch schon über die ersten Programmiersprachen, die
es so gab, ja also auch so ganz weit zurück, ja, in den
Achtzigern und so weiter ja, also wir sprechen von heute,
gucken wir uns mal an, C und C plus Plus und und wie sie alle
sind, ja. So, wenn man jetzt über
Programmiersprachen nachdenkt und überlegt wie, wieso n
Programm überhaupt läuft, ja dann, dann muss man erstmal
feststellen so n Programm läuft im Prinzip erstmal von oben nach
unten. Ja ich schreib es halt irgendwie
in den Editor hin, heute sind das irgendwie so tolle IDES, die
ganz viel können und jetzt auch AI Integration haben und so
weiter aber am Ende des Tages ist eigentlich nur Text der
Quelltext nämlich den ich in einem beliebigen Editor
aufmachen kann und ich schreib in jede Zeile ne Anweisung von
meinem Programm, ne. Und wenn ich erstmal nichts
Besonderes mache, dann dann läuft das Programm von ganz
oben, von der ersten Zeile durch immer eine Zeile weiter.
Ja so, und wenn ich, wenn ich mein ganzes Programm, meine
ganze Logik so aufbaue, dass ich einfach Zeile für Zeile für
Zeile durchgehe, dann nennt sich das Imperativ aufgeschrieben ne,
und da kann ich dann auch gar nicht mehr so viel machen, ich
springe also quasi nicht wild in diesem in diesem Quelltext hin
und her, sondern es geht tatsächlich Zeile für Zeile
runter, ich hab so n paar Sachen wie.
Konditionen, das kennt, das kennen wir ja alle.
Ja, if than else. Also ich schreibe zum Beispiel,
wenn das und das ist, dann machst du die Zeile, Else machst
die andere, das heißt, es kann schon mal hüpfen, ja, weil im
Speicher irgendwas ne Variable ist, die dann jetzt quasi nicht
nicht schwul ist. An dem an der Stelle also hüpft
es quasi weiter, ja oder ich hab sowas wie schleifen, das gehört
auch alles zum Imperativen programmieren, dass ich sage,
solange irgendwas noch nicht wahr ist, machst du das im Kreis
ja, bis es da ist, ja. Oder so n vor Loop.
Ja, wenn du so n Array durchgehst ja, also für alle
Einträge in diesem Array machst du wieder irgendwas und so
weiter ja und ganz früher gab es noch so n so n Mittel und so
N-Weg um im Imperativen irgendwie Sachen Anzuspringen,
das ist ziemlich stark verteufelt, heutzutage macht man
gar nicht mehr, es hat sich herausgestellt, dass es gar
keine gute Idee ist für die Lesbarkeit des Codes und für die
Wartbarkeit ist das sogenannte Go too.
Ich glaub in irgendeiner Folge hatte ich glaub ich auch schon
mal go too erwähnt, ja. Also mit so einem Goto kannst du
halt. Das sagst du halt quasi im
Quelltext. So jetzt die Anweisung dieser
Zeile, heißt halt quasi hüpf an ne beliebige andere Zeile.
Ja du kannst tatsächlich sagen, es war noch so, im Basic kannst
du sagen goto 70 oder Irgendsowas und da hast du quasi
die Zeilen auch noch nummeriert als Teil des Quelltext ist nicht
als nicht der Editor hat dir das durchgezählt, sondern Quelltext
mit Anweisung war halt die Zeilennummer ja und hast gesagt
go to 70. Also wenn du eine eine eingefügt
hast, dann musst du alle einmal alle alle hochzählen oder wie
ja. Deswegen hat man die 1020 30
gemacht und wenn du das vergessen hattest, dann konntest
du dann noch mal die 31 oder so dazwischen quetschen.
Ja, das war früher, bei mir war das alles noch ziemlich
hardcore, ja, aber das führt natürlich dazu kann man sich
jetzt vorstellen. Wenn du jetzt also einfach von
oben da runter schreibst und hast halt quasi nur IF LS und so
n paar Schleifen und so n Switch Statement oder Irgendsowas und
deinen Code oder aber großen willst relativ viel machen.
Ja, dann kriegst du n relativ großen Klumpen Haufen Codes und
es wird relativ sehr zügig unübersichtlich.
Ja dann springst du noch von go too.
Du versuchst, du hast ja oft hast du ja das Problem, dass du
noch mal ne Sache noch mal machen musst, die du schon
irgendwo hingetippt hattest. Ja, und dann springst du da
wieder hin mit so einem Go too. Dann lässt du das laufen, dann
springst du wieder zurück und sofort und so weiter ja, das
wird richtig Schlamassel. Ja und das nächste Level und das
gibt es auch schon sehr sehr lang, das ist das Prozeduale
programmieren Punkt 2 quasi jetzt auf meiner Liste.
Immer noch vor dem objektorientierten ne und was
hat das Prostituale programmieren quasi dem
operativen Programmieren hinzugefügt?
Das sind die Funktionen, so Funktionen haben wir ja auch
schon tausendmal gesagt, aber Funktionen sind halt quasi, sind
halt irgendwie ja das Salz in der Suppe von von jedem
Quelltext erst exakt wichtig warum?
Weil ich weil ich jetzt kann ich jetzt habe ich die Möglichkeit
schon mal Quelltext hinzuschreiben, den ich
wiederverwenden kann, erstens. Und zweitens ja nicht sofort
ausgeführt wird, den ich quasi aufrufen kann mit einer Zeile
Code. Ja, also ich schreibe schon mal
im Vorhinein irgendeine Funktion auf, zum Beispiel Average, mach
mir nen Mittelwert und wenn ich das Hinschreibe ne Funktion, das
haben alle Funktionen gleich, dann muss ich sagen, dann muss
ich definieren mit was ruf ich denn die Funktion auf.
Also ich gebe Parameter über variablen Speicher ja wo
irgendwie schon mal was drin stand, ja.
Also bei einem Mittelwert würde man typischerweise nen nen Feld
oder n array wie man sagt auf Englisch von von Zahlen quasi
mitgeben und die Idee der Funktion ist aus diesen Zahlen
quasi n Mittelwert auszurechnen. Ne können wir alle, man muss
also quasi alle zahlen addieren und durch die Anzahl der Zahlen
teilen und das ist jetzt das zweite Konzept, dann kommt was
zurück, der Return wert ja also Funktion ich geb was rein und
ich krieg was zurück das passiert aber dass die Funktion
wird nicht einfach aufgerufen sofort wenn das Programm
losgeht. Das ist der Knackpunkt.
Ich kann diese Funktion schon mal irgendwo hinschreiben und
ich hab auch noch nicht definiert, mit was die genau
aufgerufen werden, das passiert nämlich erst zur Ausführungszeit
des Programms, aber jetzt kann ich quasi, wenn ich noch mal
noch mal von top down losgehe, ich könnt ja sagen, ich hab n
Programm, das soll aus den Eingaben wenn es n
konsolenprogramm ist. Ich schreib quasi my Program
oder my averager und dann geb ich dahinter einfach Nummern an,
dann läuft das Programm und es kommt und wird und printet quasi
zum Schluss einfach den Mittelwert auf die Konsole, ja.
So, dann könnte ich quasi diese ganzen Eingaben verarbeiten, die
ich ja vorher noch nicht kenne im Programm.
Als ich den Quelltext geschrieben habe, wusste ich ja
nicht, was derjenige dann da eintippt, so, das heißt, ich
nehme die alle auf Les, die quasi aus der Kommandozeile, das
kann man machen und dann rufe ich dieses diese Funktion
Average auf, an einer Stelle code, dann springt es dahin, der
Programmfluss springt dann in die Funktion, ruft die auf, dann
geht der Programmfluss und das ist wichtig wieder Zeile von
oben nach unten in der Funktion, denn die Funktion ist ja auch
implementiert. Mit mit dem, was sie halt tun
soll. Ja, die hat also quasi so ne
Funktionsdeklaration, nennt man das oben den Header, das ist
sehr unterschiedlich, da sag ich gleich noch was zu zu den
verschiedenen Programmiersprachen und dann
kommt der von quasi der Buddy so man sagt mal, also quasi der
Inhalt der Funktion und das letzte Statement ist
typischerweise Return und mit dem Return wird quasi wieder
wieder n Wert zurückgegeben aus der Funktion und mit dem Return.
Das heißt deswegen auch Return also Return zum Ursprungspunkt
wo du hergekommen bist zurück ja.
Das heißt, irgendwo im Code ruf ich ne Funktion auf, dann
passiert das und dann springe ich zurück mit dem Return und
geb aber auch den Wert zurück, den ich dann weiter benutzen
kann. Kurze Frage, weil du hast das
jetzt gerade so betont, dass da jemand also was eintippt, zum
Beispiel diese Nummern, die dann also den My averager und dann
die Nummern und dann wird irgendwo die Funktion mit n
Average aufgerufen. Nimmt dann diese Nummern macht n
Average, war das bei der Imperativen Software oder Art
und Weise kurz zu schreiben nicht möglich.
Von außen Input Reinzugeben, dann in das Programm.
Klang gerade so n bisschen so, weil du so betont hast, nee nee,
das verging auch beim Imperativen kannst du genauso
machen, bloß da hättest du dann quasi sagen müssen der Reihe
nach. Ja jetzt lese ich Argument 1 von
der Konsole jetzt 234 bis ich keins mehr finde, das hättest du
auch machen können und jetzt würdest du aber quasi sofort im
im weiteren Fluss des Programmes dann sagen müssen, so und jetzt
in der nächsten Zeile rechne ich die zusammen ja was ich gefunden
hab ja irgendwie a 1 plus a 2 plus a 3 plus a 4.
Und weil sich das noch mal ne Variablen zu die irgendwie die
Summe ist, ja könnt zum Beispiel sagen, Summ ist gleich a 1 plus
a 2 plus a 3 plus a 4, die ich vorher gelesen hab, aus der aber
alles der Reihe nach ja so und dann will ich noch mal sagen
Summ, geteilt durch die Anzahl von denen und dann will ich es
ausprinten und fertig, ja dann hätte ich das aber alles quasi
unstrukturiert Zeile für Zeile runtergeschrieben.
Ja, während das prozedurale Programm auch die Parameter von
der Konsole liest und wenn sie es aber hat, dann würde sie
sagen Ruf auf ja average Funktion.
Also es wird richtig aufgerufen, dann kann man dann, das kann man
quasi per Name, die Funktionen haben immer nen Namen im
Quelltext und dann ruf ich einfach mit dem Namen, der
Funktion und den Parametern, die übergebe ich das auf und dann
kann ich quasi in einer Zeile code kann ich das Everage
berechnen lassen ja, also in der in der ich die gerade lese, ja
und irgendwo in einem anderen Pfeil oder auch in dem gleichen
Pfeil, aber an einer anderen Stelle sauber getrennt, optisch
auch visuell ne für den Entwickler steht diese Funktion
oben ja so, dass das nicht einfach so n Haufen.
Quelltext ist ja, man hat halt festgestellt und es ist auch
heute noch so. Wenn du zu viele Zeilen Code,
die irgendwas machen tatsächlich untereinander schreibst, ja dann
dann wird das ist das menschliche Hirn einfach
überfordert, das einfach wahrzunehmen, was da passiert.
Ja, also man sagt ja sogar so, Funktionen sollen im Schnitt so
zwischen 5 und 10 Zeilen Code nur haben wieder die sie tun,
ne. Aber dann bekommt halt dieser
dieser Block Funktion, der bekommt halt einen kleinen
Namen. Du machst das ganz ganz
kleinteilig. Ja und du kannst ja in Funktion
auch wieder Funktionen aufrufen und so weiter das kannst du dann
verschachteln ja, aber du teilst quasi die Logik in viele kleine
Stückchen, auf die man gut verdauen kann, auch so vom Lesen
her ne und vom Verstehen her und vom Warten auch her.
Ja du kannst das gehört ja zur Testbarkeit dann auch dazu,
kannst du später komme ich viel später erst zu, aber du kannst
dann quasi Funktionen ja auch einzeln testen und gucken ob die
funktionieren für die verschiedenen Werte die sie so
haben ne. Und in der Praxis wird das so
befolgt, also dass man wirklich Funktionen so unterbricht und
Splittet, dass sie immer nur ganz, ganz kleine Blöcke von 5
bis 10 Zeilen sind und ich mein es, es klingt ja erstmal
aufwendiger manchmal dann, wenn jetzt nur nur ne ne Funktion
aufbricht, um des kleinermachen willens quasi, klingt aufwendig,
ja. Genau das ist also das ist NNN
schwingendes Thema unserer ganzen Folge.
Hier ist es ist das Engineering und das over Engineering, ja.
Es ist wie alles im Leben. Ja, du kannst es übertreiben,
dann wird es, dann ist es over engineered, dann hast du es zu
klein geteilt. Ich muss aber sagen im echten
Leben, es ist schon so, es gibt da auch viele Bücher dazu,
tatsächlich sind die sehr kurz, ja, also wenn du n guter
Entwickler bist, hältst du die sehr kurz, ja und das geht auch
und so n so n Daumenriegel von mir ist so n bisschen macht das
in ne Funktion was du das erste Mal zweimal benutzt weil wir
haben das große Konzept Don't repeat yourself.
Und das gilt, wenn du Sourcecoach schreibst.
Also wenn du den Quelltext schreibst, schon sehr sehr
stark. Wenn du zweimal exakt gleichen
Teilen Code schreibst, an verschiedenen Stellen in deinem
Quelltext, dann ist es schon n Zeichen dafür, dass das in
Funktion muss. Ja, weil dann rufst du einfach
lieber zweimal diese Funktion auf, die sehr kurz sein kann,
als dass du zweimal an verschiedenen Stellen das
Gleiche machst. Ja, was du vergessen hast
später, was du dann einmal fix und das andere nicht und so
weiter also. Es tut nicht weh.
Funktionsaufrufe sind auch in den Programmiersprachen so
unglaublich schnell, das tut auch keiner Performance weh.
Ja, also es macht überhaupt keinen Unterschied mehr, also
die Empfehlung ist schon alles in viele kleine Funktionen zu
schreiben um die aufzurufen. Eigentlich ist so ein Quelltext
voll von vielen, vielen, vielen vielen Funktionen ne und dann
gibt es so einen Code der sich durchzieht, der quasi den roten
Faden durch die Anwendung findet und dann immer wieder Funktionen
aufruft. Gut, dann noch Zwischenfragen
gestellt zu. Finde ich alles gut.
Ne, das sind ja wenn wenn man wenn man halt nicht so viel
Source Code schon gelesen hat, dann ist es ja irgendwie auch,
das ist total schwierig das auch mal zu erzählen, also aber man
kann ja Python Source Code mal so n bisschen lesen das man kann
sich auch mit der mit KI mal n bisschen Python Code zeigen
lassen und so weiter ich hab mal rausgeguckt spannend wird diese
Folge schon mal geguckt was so wie man so die Funktionen
deklariert in den verschiedenen Programmiersprachen, also wie
das heißt quasi ja tatsächlich ist, nämlich so das heißt es ist
immer Englisch. Also auf dem javascript, was wir
hier viel benutzen im Note GS, da heißt es tatsächlich function
ne, da schreibst du hin wenn du ne Funktion definieren willst,
dass das Keyword das sogenannte Programmierkeyword function,
damit das mit der Interpreta der da später dann irgendwie
interpretiert quasi deinen Code, der weiß was los ist.
Ja, und das ist auch so in PAP, da heißt es function ja in der
Programmiersprache go heißt es noch Funk.
Haben sie abgekürzt? Ja, und in zum Beispiel in
Kotlin, Kotlin ist ist so ne Hochsprache für Android, also
wenn du nicht das nicht in Java hinschreiben willst, sondern in
so einer Art, so einer einfacheren Sprache, da ist es
nur noch Fun, also Fun abgekürzt und am kürzesten ist Rust.
Da haben Sie es nur noch FN genannt, so ne Funktion und ganz
bekannt ist und ganz andere Namen hat es in Python, was
viele Leute hier kennen und auch in Ruby heißt es def.
So das sind so die Funktions Funktionskeywörter ja.
In anderen Sprachen, die die sehr stark objektorientiert
sind, da kommen wir jetzt gleich zu.
Dann haben die Funktionen gar keinen eigenen Namen mehr
Funktion, das ist einfach, da schreibst du nur noch den
Funktionsnamen hin und die entsprechende Syntax und dann
weißt schon, der weißt schon, der Compiler, in dem Fall.
Typischerweise ist es dann kompiliert hier so wie in zum
Beispiel in C plus Plus und Java, da schreibst du nur noch
den Namen quasi hin und den den Returnwert erst und dann den
Namen und dann die Eingabeparameter, dann paar
Klammern und so weiter und sofort da ist das so festgelegt.
So liebe Leute hier nur ein kurzer Hinweis.
Wir sind wieder auf Messen und Konferenzen unterwegs und
möchten euch dazu einladen. Und zwar sind wir am 14.
Und 15. Mai auf der Hausmesse der Firma
Hedelius. Hedelius ist Kunde von uns und
ein Hersteller von CNC Bearbeitungszentren, dort gibt
es ja viele viele Bearbeitungszentren und
Automatisierer und Software zu sehen, dort wird Burkhard sein.
Ich bin zeitgleich in Barcelona auf der IOT Solutions World
Congress. Das findet vom 13.
Bis zum 15. Mai statt.
Dort haben wir natürlich auch Freitickets sowie ein paar
wenige Full Access Tickets, das heißt auch inklusive der
Konferenz, die dort parallel stattfindet.
Falls du Interesse an einem solchen Full Access Ticket hast,
schreib uns doch ne kurze e Mail an podcast@heißenweb.com.
Ihr findet Informationen zu Herr Delios Hausmesse und zum IOT
Solutions World Congress im Link Tree, in unseren Shownotes und
wir würden uns freuen, wenn wir euch dort treffen.
Hinweisende gut also jetzt hatten wir Imperativ, ist quasi
einfach Top Down Runterschreiben von Anweisungen führt zu
unleserlichen großen Spaghettihaufen.
Prozedural ist zum Beispiel also ich sag mal was ANSI c, also die
alte gute alte C Sprache, die es ja auch noch überall gibt.
Sag ich mal. Ist ja nicht weg, wird noch
genutzt in der maschinennahen Programmierung oder auch wenn
man quasi neue Programmiersprachen programmiert
hat, sind die auch gern mal in C geschrieben hat als als
strukturierendes Konzept auch nur dieses Prozedurale das
Funktionskonzept C hat nicht die Idee von Objekten und Klassen.
Ja da kommen wir jetzt zu, das ist aufgekommen im Jahr 67 1967,
da gab es mal simular hab ich nie programmiert, weiß nicht wie
das aussieht. Das war aber so und das war,
glaube ich, die die Programmiersprache simula war
eigentlich eher so zum Trainieren, zum zum
beispielhaften, zum Lernen. Ich glaube, das war gar nicht so
ernsthaft genommen, dass es irgendwie seriöse Anwendungen da
rauskommen sollten, kamen sie dann aber später auch noch, war
so der Vorreiter und hat im Prinzip dieses Konzept das
allererste Mal realisiert, nämlich der Klassen und der
Objekte, was sind jetzt Klassen und Objekte, im Prinzip ist das
also, Klassen und Objekte sind erstmal.
Nur was für Entwickler? Ja, also man muss sich erst mal
fragen, was ist überhaupt Object Orient Programming für wen hat
denn das jetzt hier einen Mehrwert?
Ja und alles dieses ganze Gedöns was wir heute besprechen,
Imperativ, prozedural, Objektorientiert der Mehrwert,
der liegt nur für den Entwickler, das sind Entwickler
Patterns, das sind Ideen wie ich schaffe wenn die Anwendung immer
größer werden, wir haben ja riesige komplexe Software
mittlerweile wie schaffe ich es? Den Kram als Entwickler oder
sogar als Team von Entwicklern irgendwie zu warten und da
durchzusteigen, wenn das groß wird, ohne dass ich da völlig
überfordert bin, denn am Ende ist so ein Programm, am Ende
macht, das Macht immer so ein so ein Interpreter oder so ein
Compiler, im Prinzip zieht er das glatt und führt eigentlich
den Kram von oben nach unten aus und setzt das so zusammen.
Also der Quelltext hat nichts damit zu tun, wie das Programm
im Maschinencode später ausgeführt wird, das ist nun mal
ein ganz anderes Level. Ja, verstehe, darauf war das
jetzt bezogen mit wo das jetzt n Vorteil hat.
Ja, aber grundsätzlich ist es ja in erster Instanz jetzt n
Entwickler und hinten raus haben ja viele Leute was davon wenn
jetzt Entwickler schneller ist einfacher Code warten kann,
Fehler vielleicht schneller wiederfindet et cetera ne das
ist spart Kosten so. Das ist klar.
Aber ich meine nur, dass die divisability, sag ich mal also
nen nen Anwender von der Software kann ja nicht wissen,
ob das mal irgendwie objektorientiert programmiert
war, was da läuft, oder? Auf welche Art und weise ich
meine jetzt quasi ne, also für wen, für wen ist dieses Pattern
überhaupt gedacht? Du kannst also alles auf alle
Arten irgendwie umsetzen und wenn man es jetzt benutzt als
Anwender, merkt man davon gar nichts.
Genau das ist, was ich sagen wollte, ja perfekt, genau so.
Und was ist jetzt, was ist jetzt objektorientiert?
Ja, also man hat jetzt im Prinzip und er findet noch mehr
Patterns außer diese Funktion die ich gerade erklärt hat um
Code noch besser intern zu strukturieren, ne.
Und da hat man sich jetzt halt das objektorientierte angeguckt
und es fügt der normalen Funktion ja eigentlich nur 2
Konzepte zu, nämlich das Konzept einer Klasse und eine Klasse ist
quasi etwas mehr als eine Funktion.
Ist eine Blau, also eine Klasse, kann Funktion schon beinhalten,
ist ein Beutel für Funktion und für Daten und diese Klassen.
Aus denen kann ich quasi zur Laufzeit dann Instanzen machen.
Objekte ja, deswegen heißt es objektorientierte
Programmierung. Ja, also das ist die Idee, ja,
damit kann ich dann quasi noch besser strukturieren, ja, weil
man hat festgestellt, dass ich, wenn ich zum Beispiel Funktion
hab, ich hab es jetzt gerade gerade genannt, zum Beispiel
Average, hatte ich gesagt, ja, jetzt könnte ich zum Beispiel ne
Funktion haben, die heißt irgendwie running Average, ja,
weil ich jetzt zum Beispiel ne neue ich hab jetzt zum Beispiel
neue Anforderungen, dass meine. Meine Daten, die ich zum Average
bilden will, da kommen immer neue Datenpunkte dazu.
So ein bisschen wie beim wie beim Auto oder irgend so was du
fährst ne und dann kriegst du so ein Durchschnittswert zum zum
Benzinverbrauch zum Beispiel und der der wird dann quasi immer
akkurater, je länger du fährst, ja oder hast dann noch andere
statistische Auswertung. Ja, was ist denn mit meinen
ganzen Datenpunkten, jetzt machst du mehr Statistik, ja was
ist denn mein Minen ne man irgendwie haben wir ja gerade
den Minen, ist ja der Dawage, aber was ist denn zum Beispiel
meine Standardabweichung? Ja, was war denn der größte Wert
und der kleinste Wert und so weiter.
Dann schreibst du dafür alles Funktionen, stellst aber fest
verblickte Kiste, die gehören irgendwie alle zusammen und die
haben ja auch die gleiche Datengrundlage.
Ja, die rechnen ja auf den gleichen Daten.
Ne, jetzt kannst du das natürlich funktional ausdrücken,
dann kriegen die halt immer wieder, da hast du immer wieder
Funktionen, die kriegen immer wieder nen Array von diesen
ganzen Daten ja und brauchen dann immer noch n paar andere
Seitenparameter aber irgendwie stehen sie also quasi mit ganz
anderen Funktionen die man nicht zu tun haben ja auf gleicher
Hierarchieebene ja. Und jetzt, im objektorientierten
Programmieren sagt man so, OK, nee, pass mal auf die, ich fasse
noch mal n hab noch n abstraktionslevel mehr wo ich
die zusammenfassen kann. Ich könnte jetzt zum Beispiel
sagen, ich hab ne Klasse, die nenne ich statistics so und in
der Statistics klasse pack ich meine ganzen statistischen
Funktionen zusammen, die ich so brauche, ja nämlich Compute
Average, compute running average oder moving average get mean
get. Get min Max, Standard,
Navigation und so weiter und kann ich diese ganze, dann guck
ich mir einmal Statistik an. Ja hab das gelernt und
Programmier die ganzen Funktionen quasi in so eine
Klasse Statistics und kann das dann quasi als als
zusammenhängender Haufen benutzen.
Ne und natürlich noch n bisschen mehr dazu erzähl ich gleich noch
mal was. Aber das musst du jetzt noch mal
genau sagen. OK, jetzt kannst du das als
zusammenhängenden Haufen benutzen, da schließt sich mir
der Vorteil noch nicht, sagen wir es mal so.
Das das musst du noch n bisschen genauer erklären glaub ich, dass
man das als Nichtentwickler auch versteht.
Warum das jetzt n Vorteil sein könnte oder ist.
Ja, ja genau, also ich, ich erzähl es erstmal so ganz grob
und ich glaube da kommen wir auf die auf die 4 Themen, die ja man
sagt auch die 4 Grundpfeiler der der objektorientierten
Programmierung kommen wir dann gleich drauf zu, warum das
einfach praktisch ist, ja. Mhm, da, damit wirst du es also
dann so quasi beantworten. Durch diese 4 Grundpfeiler
verstellen. Ja genau, es ergibt sich ja zum
Beispiel, dass du, dass es praktischer ist, im Code zu
sagen, Pass mal auf, das sind alles meine Datenpunkte und ich
brauche jetzt statistische Auswertung, zum Beispiel ja so,
und jetzt jetzt kann ich zum Beispiel eine Instanz von so
einer Klasse erstellen, die zum Beispiel Statistics heißt, und
jetzt habe ich eine, wenn ich Klassen hab, dann habe ich eine
spezielle Funktion, und das nennt die nennt sich der
Konstruktor. Also es ist auch.
Also ich hab ja gerade gesagt, Klassen sind im Prinzip nichts
anderes als nen neues Abstraktionslevel über den
Funktionen und Klassen können Funktionen haben und eine es
gibt aber eine sehr spezielle Methode, das ist nämlich die
Methode quasi die aufgerufen wird, wenn aus diesem aus diesem
Stück Code, das ja feststeht, eine neue Instanz, wie man sagt,
ein Objekt einer Klasse hergestellt wird.
Ja, das nennt sich der Konstruktor so und der
Konstruktor. In unserer Statistikfunktion der
würde typischerweise jetzt einmal dieses Feld von Zahlen
bekommen, auf der die Statistik dann ausgeführt werden soll,
also den Array von Nummern zum Beispiel ja im Konstruktor.
Und jetzt gibt es was Neues jetzt, und das ist wichtig,
jetzt können in der Klasse und den Objekten können jetzt quasi
die Daten, die ich normalerweise hab.
Die typischerweise beim beim in der nur Prozeduralen, nur
funktionalen Programmiersprache immer nur außen gehalten werden.
Ich muss ja immer, ich hab ja beim Programmieren immer zu tun
mit Speicher und mit variablen, ich muss mir ja mal was merken
und dann kann ich irgendwie ne Logik drauf aufrufen ne so
unsere Average Funktion im ersten Falle da muss ich quasi
mir ne mir mir die die Zahlen von außen merken die ich
überhaupt auf denen ich der Statistik machen will, dann
packe ich sie in ne Funktion und dann kriege ich n wert zurück.
Dann muss ich mir immer noch außen merken, wenn ich die
zweite Funktion auf aufrufen will und so weiter ja und ich
muss mir auch das Ergebnis wieder außen merken und wenn ich
jetzt quasi mit dem Average irgendwas rechnen will, dann
muss ich es wieder von außen reinkippen, wenn ich Klassen und
Instanzen habe, dann werden die Daten auch gebunden in der
Instanz. Also wenn ich jetzt diesen
Konstruktor Aufrufe und übergebe einmal dieses Feld von Nummern,
dann kann ich eine einen Speicher anlegen und das nennt
man member Variablen. Die gehören dann nur dieser
Instanz, die ich dann aufgerufen hab, dieser Klasse.
Das heißt, diese Instanz der Statistikklasse merkt sich die
Zahlen, auf denen ich später arbeiten will und das Macht auch
Sinn, weil ich zum Beispiel verschiedene statistische
Auswertungen immer wieder auf diesen gleichen Zahlen machen
muss, und das heißt, dann habe ich also ne member Variable, zum
Beispiel Data, das ist die Datengrundlage, wenn ich jetzt
die Funktion Average aufrufe, dann kann ich die aufrufen, ohne
dass ich irgendwelche Sachen übergebe.
Ja, jetzt würde ich quasi. Von der Instanz, die ich
bekomme, und das muss man auch erstmal machen.
Du sagst dann quasi New Statistics Klasse und der
übergibst du jetzt das Feld, dann wird der Konstruktor
aufgerufen und dann bekommst du eine eine Variable in die Hand,
die heißt dann irgendwie zum Beispiel Statistics
kleingeschrieben oder irgendsowas, also macht man das
normalerweise so und und das repräsentiert jetzt quasi ein
Objekt der statistiks Klasse. Was da drin schon Daten hat,
gespeichert alles für mich ja, nämlich zum Beispiel die also,
die in dem Fall die ganzen Nummern.
Und jetzt rufe ich nur noch auf Statistics Punkt Average Klammer
auf Klammer zu und muss nicht mehr die Daten übergeben, weil
die sind quasi schon Intrinsisch mit eingebaut in die Instanz aus
diesem Average Call kriege ich quasi das Ergebnis direkt raus.
Ja und vom Programmieren her sieht so aus, dass ich in der
Klasse Statistik habe ich die Methode Average ist eine ganz
normale Funktion. Erstmal von außen gesehen, aber
da sie in der Klasse definiert wurde, wird das jetzt eine
Member Funktion, eine sogenannte ja also sie sie ist aufrufbar
nur und sinnvoll nur wenn ich vorher eine Instanz erzeugt habe
über den Konstruktor, ja dann kann ich diese Funktion Average
aufrufen und dann kann ich mich auch und das sieht man als
Programmierer, ich kann mich dann innerhalb dieser Funktion.
Auf die Daten beziehen, die der Konstruktor abgespeichert hat,
vorher. Typischerweise ist das This oder
Self, also viele Programmiersprachen machen das
klar, wo kommen jetzt meine Daten her?
Ja dann kann ich nämlich This Punkt Data adressieren oder Self
Punkt Data im Python ja This ist mehr so das javascript oder C
plus Plus und im Python heißt das Self ja um zu sagen das sind
meine Daten mehr oder weniger ja.
Du hast jetzt Methoden gesagt und Funktionen ist das Synonym.
Ist das das Gleiche eigentlich oder?
Also ja, es sind alles Funktionen, aber es gibt quasi 2
neue Arten von von Funktionen. Es gibt diejenigen, die in der
in in der Klasse gebunden sind, die Member Funktionen und es
gibt dann auch noch andere statische Funktionen, nennt man
das, das ist wichtig, die kann ich, die sind auch quasi
geschützt von der Klasse die funktionieren aber ohne Instanz.
Das ist im Prinzip eigentlich nur ne Adresserweiterung von der
Funktion, da sortier ich quasi die nur zusammen.
Die funktioniert eigentlich wie ne alleinstehende Funktion, so
kann man sich es vorstellen, aber ich sage halt zum Beispiel
Statistik, Punkt, Average und dann hat die aber keine Daten,
kann die sich nicht auf Daten beziehen, da müsste ich jetzt
wieder alle Zahlen eingeben von außen.
Ja würde jetzt in dem Beispiel keinen Sinn machen, aber das
gibt es ja also Funktion ist das generelle Ding und wenn man
jetzt objektorientiert spricht, dann hat man 2 neue Arten von
Funktionen, nämlich die member Funktion.
Sind die oder instanzfunktionen und statische Funktionen das
sind die auf Klassenlevel. Das fand ich jetzt sehr
hilfreich. Längst hab ich gefragt, ob
Methoden und Funktionen das Gleiche sind.
Ja, ich würde sagen Funktion ist allgemeiner ne und Methoden sind
wenn man sagt Methode, dann meint man immer eigentlich ne ne
Methode der Instanz, also eine die eine Funktion die erst dann
verfügbar ist wenn ich vorher ne Instanz einer Klasse erzeugt
hab. Das ist das spezielle Wort
Methoden, ansonsten sagt man eher wenn man es wenn man nicht.
Wenn man nicht genau sagen will, dass das jetzt ne member
Funktion ist. Ich nenn es immer member
function. Ja und dann sagt man ja es ist
irgendeine Funktion, aber wenn man sagt ne Methode auf dem
Deutschen, dann meint man eigentlich eine Funktion einer
Instanz genau und jetzt es gibt 4 Kernkonzepte der
objektorientierten Programmierung, da sagt man das
ist Abstraktion, kapselung, Vererbung und Polymorphie die
kommen jetzt quasi als von dem was wir jetzt so gehört und
verstanden haben kommen die so n bisschen mit ja.
Und warum will ich das haben? Ja, ich also wenn jetzt Code ne
Codebase groß wird und wenn zum Beispiel viele Entwickler
irgendwas machen, ja dann muss ich Übersicht bekommen.
Ja das ist so n bisschen man kann so n bisschen vergleichen
mit mit einem Word Dokument wo ich irgendwie Überschriften
einfalten kann natürlich ich wenn ich so n 400 Seiten
Dokument hab und mir ne Übersicht verschaffen, ja dann
ist es irgendwie cool wenn es irgendwie n Inhaltsverzeichnis
gibt ja oder irgendwie Überschriften Gliederung ja
Sektionen die kann ich halt falten ja.
So n Akkordeon Ding da ne ja. Ja, sowas in der Art.
Ja und ich und und wenn ich so ne wenn ich so Zusammenfassung
habe von von Überschriften und so weiter das kann ich halt
machen wenn ich Klassen habe, dann hab ich quasi, dann kann
ich quasi für diese Klasse in diesem Namensraum dieser klasse
kann ich so ne Art ganz gerne NAPI ja kann quasi definieren
was was sind die Methoden die man nach außen kennen muss, ja
man nennt das auch Public Message ja NT plus Plus hat das
auf die Spitze getrieben, da wird das genau.
Wird es genau hindefiniert. Du kannst nämlich ja auch
Funktionen brauchen können auch sogar member Funktionen, die
Hilfsfunktionen sind um das zu tun was deine klasse können
soll. Ja sagen wir mal du hast jetzt
ne ne ne ganz krasse statistische Auswertung was weiß
ich fällt gerade nichts ein wo wo schwierige Berechnungen
angestellt werden müssen wo du quasi das diese ganze Berechnung
auch nicht wieder in einer Funktion machen willst, nämlich
die die der Nutzer auf aufruft, sondern.
So wie ich vorher gesagt hab 567 Zeilen ne schaff ich nicht, also
hab ich noch mal hilfsfunktionen ne, aber diese verdammten
Hilfsfunktionen, die sind nur sinnvoll im Zusammenhang mit
dieser einen oberliegenden Funktion, die du eigentlich nach
außen geben willst. So ja und jetzt kannst du also
in der Klasse trotzdem noch hilfsfunktionen schreiben und
auch Hilfsvariablen haben und Hilfsdaten und alles mögliche
kannst aber sagen die sind privat, die zeig ich nach außen
hin nicht. Nach außen hin heißt nach außen
zum Entwickler ja selbst wenn du es selber schreibst, so irre ist
das, aber man es ist ja so, dass du viel Code schreibst und du
vergisst das auch wieder. Ja und der nächste Entwickler
kommt rein ja, also man versucht mit mit diesen, mit dieser
objektorientierten Programmierung so ne Art Apis
auf kleinstem Level zu schreiben.
Ja ich sag halt diese Klasse, die soll halt das und das machen
und das sind die Hauptfunktionen ja und wie die das macht und und
was ich dann noch für hilfsfunktionen hab, das
schreibe ich da auch rein in die Klasse.
Kennzeichne ich aber als privat mehr oder weniger und dann ist
es total sauber und dann kann ich auch wenn wenn wenn wenn ich
die weiter benutze die Klasse, dann mach ich quasi nichts
falsch, dann kann ich nicht falsch bedient werden.
Ja ich schütze mich davor den Code falsch aufzurufen, quasi.
Ja das ist so n bisschen das Abstraktionslevel ja.
Also macht es auch. Könnte man auch schon sagen,
auch auch wenn du sagst für größere Teams sinnvoll macht es
Teamarbeit auch irgendwie in gewisser Weise einfacher ne mit
mehreren Leuten am Code zu arbeiten.
Ja, auf jeden Fall. Genau.
Und Encapulation spielt da in die, in die in in die gleiche
Richtung. Ne.
Also ich hab also Abstraktion ist quasi ich les quasi was die
tun kann, das sind quasi die Überschriften und Encapulation
ist das was ich sagte, dass dass du quasi auch diese ganzen
Daten, state, ja alles was du an Hilfsvariablen brauchst und so
weiter das muss ich alles nicht wissen, das wird alles
weggekapselt ja ich ruf einmal mit dem Konstruktor das Ding
auf, ja zum Beispiel mit dem Riesen Array von Nummern.
So, und jetzt kann es wichtig sein, dass bestimmte Algorithmen
da irgendwie Teile von diesem Array genommen werden.
Ja, bei Bildverarbeitung zum Beispiel, dass ich das im
Speicher noch mal ganz anders hinlege, ne immer 4 * 4 Pixel
werten und so weiter und sofort, ja das weiß alles, die Klasse
und Instanz selbst. Da muss ich aber als als Nutzer,
also Entwickler, Nutzer von dieser Klasse nichts von wissen,
ja das wird also alles gekapselt.
Und ja, und ich darf dann bestimmte Funktionen auch nicht
aufrufen. Das verbietet mir dann sogar,
wenn der der Compiler kann das verbieten ja wenn das der
Entwickler gesagt hat hier, das ist privat, das darfst du nicht
direkt aufrufen von außen, dann darfst du es auch nicht, ja.
Ja, noch mal kurze Zwischenfrage wegen mit dem zu dem, wenn es
gerade passt, zu dem Aufrufen. Du hast ja gerade gesagt,
Aufrufen und dann n großes Array von von zahlen wenn ich jetzt ne
Klasse Aufrufe krieg ich dann im Code schon angezeigt was die
Klasse dann auch haben möchte als.
Input oder als als als als Argumente oder sowas?
Oder wie läuft das? Musst du es wissen.
Na ja, also du, du kannst es immer wissen, weil ja der
Quelltext irgendwo steht. Ja OK, kannst nachgucken.
Ja, also. Kannst du nachgucken, aber, aber
tatsächlich ist das nachgucken ist dann ja auch wieder, musst
du ja auch wieder Source, gut lesen, dann musst du diese
ganzen public private Dinger wissen und sofort, ja
tatsächlich ist so heute durch die Idee ES also durch die
Integrated Development Environments im Prinzip durch
die Editoren und Steroids. Die wissen genau das, also die
machen du. Du erzeugst so ne Instanz und
tippst du den Punkt dahin oder den Fall, je nachdem welche
Programmiersprache um quasi jetzt vielleicht n
Methodenaufruf hinzuschreiben, der auf dieser Klasse da ist und
dann passiert genau das. Du kriegst quasi so nen tooltip
Menü und dir sagt quasi deine Idee, Pass mal auf diese Klasse
hat die und die Funktion, die kannst du jetzt benutzen und oft
sind die auch sehr gut dokumentiert, weil das sind ja
die Public Funktionen, dabei hast du ja du hast wenn du als
Entwickler ne Klasse geschrieben hast.
Und hast bestimmte Funktionen, die du möchtest, dass die andere
benutzen können. Und Dokumentierst du die auch im
Code? Ja, und diese ganze
Dokumentation, diesen ganzen Krams, das Parsen die IDES die
ganze Zeit durch und das wird dir angezeigt, wenn du sie dann
benutzt. An der anderen Stelle, ja, und
das ist mega praktisch, oft brauchst du dann gar nicht so
viel lesen, ja, weil Gerrit ja auch ne Wahrheit ist, dass du
die Klassen ja auch nicht nur selber schreibst, sondern du
benutzt ja auch ganz viel Code von anderen als als Dependency,
als Third Party mit. Und und wie benutzt du denn
Third Partys? Ja, du benutzt deren Objekte und
deren Klassen, ja und es wird dir dann ziemlich sauber
angezeigt. Wie kannst du das benutzen?
Ja du kannst ja auch nicht erwarten, dass das kann keiner
können, ja, dass du den ganzen Code den ganzen Dependency
source Code, den du dann wovon du dann 23 Funktionen brauchst
oder oder Funktionen die members Methoden von Klassen, da willst
du nicht den ganzen Code lesen ja und du willst dir aber
trotzdem sicher sein, dass du das richtig benutzt.
Ja und insofern. Gibt das quasi dieses
objektorientierte Programm programmieren vor?
Cool, dann warst du gerade mit der Encapstulation durch.
Genau dann gibt es noch diesen Punkt Vererbung bei diesen
Pillars. Da steht dann immer schon nicht
mehr composition. Ich würd das jetzt dazu packen
an der Stelle, aber ich sag erst mal kurz was Vererbung ist.
Also die Idee ist, wenn du so ne Art ja wenn du so ne Art
Blaupausen hast, dass du dann sagst ich Erbe schon mal ne
ganze Menge Eigenschaften. Von einem bestehenden Template,
also ich spezifiziere das noch mehr aus.
Ich gebe jetzt mal ein Beispiel, wir hatten ja die ganze Zeit von
statistiks Klasse gesprochen, wo irgendwie statistische Methoden
sind, ja, die könnte zum Beispiel von einer
grundlegenderen Klasse erben, die einfach nur Mars heißt, also
Mathematik ja, und in der Mathematik Klasse sind noch viel
grundsätzliche Funktionen drin oder so ne, die haben jetzt das
vielleicht nicht mit der Statistik zu tun, aber die.
Was weiß ich, die können irgendwelche trigonomenischen
Sachen machen, Sam und Ed und so weiter und sofort ja.
Ja, das passt ja hier. Du hast ja vom Average schon
davon gesprochen, dass du ja da auch ne Sam bräuchtest.
Dann ne. Ja genau das, das würde passen.
Ja, und das gibt es halt ganz, ganz oft.
Ja, und das ist wie im Leben, ja, das gibt halt, wenn du
kannst halt Templates für alles machen in deinem Leben, ja und
dann kannst du grundsätzlichere und feinere ja und wenn du jetzt
quasi die Vererbung nicht hättest und würdest aber das
statistiks Ding hinschreiben wollen.
Ja, du musst doch halt irgendwie noch mal alles hinschreiben, was
du dafür brauchst. Ja, so und eventuell ist aber in
der in der Maßfunktion schon was drinne.
Ja was du benutzen kannst. Ja und auf meinem Level
Statistics gibt es vielleicht noch n anderes Level, das heißt
was weiß ich imageprocessing oder irgendsowas ja weil ich
jetzt nicht Statistik machen will, sondern ich will jetzt
irgendwie imageprocessing Algorithmen machen, so da brauch
ich aber auch Mathematik Algorithmen ja und wieder die
gleichen so und jetzt kommt wieder das Konzept Don't repeat
yourself ja wie Krieg ich das jetzt hin?
Das jetzt irgendwie nen nen Image Processing klasse und ne
statistics klasse nicht wieder irgendwelche grundlegenden
mathematischen Operationen implementiert, sondern dass die
irgendwie beide das haben können.
Ne und jetzt kommt das Konzept der Vererbung an Start und jetzt
sagt man OK ich bau halt meinen Code so auf, dass ich versuche
alle Probleme so zu schneiden und zwar jetzt nicht nur in
Funktion zu schneiden sondern in Klassen zu schneiden, dass ich
halt grundsätzlichere Klassen habe und feinere Klassen.
Und feinere Klassen können quasi von Grundsätzlicheren Erben.
Ja, und jetzt sagt man zum Beispiel Statistics erbt von
Mars ja und Image Processing erbt vielleicht auch von Mars,
ja, es kann nämlich so sein, dass verschiedene Klassen auch
von der gleichen Base Klasse erben, ja, und in manchen
Programmiersprachen ist es sogar so krass, dass man, dass man
grundsätzlich, dass man so in der Programmiersprache sogar
angelegt hat, ne Object als die Basis, Basis, Basis, Klasse
aller Klassen, ja, da stecken halt irgendwie so ganz
grundsätzliche Dinger drin, wie irgend weiß ich nicht.
Zum Beispiel wie wie pack ich irgendwas auf n Screen raus?
Ja so n Print oder Irgendsowas ja dann hab ich quasi ne
erbhierarchie und da erbt erstmal jeder von Objekt ja so
und dann erben die noch weiter und so weiter dann krieg ich so
baumierarchien ne so richtige große Graphen.
Ja Java ist so ne Sprache, da erbt immer alles von allem ach
das da, da hast du immer ganz viele so und dann kannst du
erstmal gucken wer und dann erb ich von der Klasse und die erbt
noch mal von wem, da musst du erstmal verstehen wer da alles
geerbt hat ja und was heißt erben heißt quasi du erbst.
Die öffentlich gemachten Funktionen, die öffentlich
gemachten Members, die erbst du ja die Privaten interessieren
dich, die hast die Funktion. Hast du dann einfach zur
Funktion, aber du erbst dann quasi die die Klassen mit so n
so n. Typisches Beispiel ist immer,
was ich nicht mag, aber hast ne ne Base klasse, die heißt Animal
und dann hast du quasi die geerbten Klassen, die ist dann
quasi nen Dog und ne Cat und Word oder irgendsowas ja und
dann dann gibt es in der Animal Klasse gibt es ne Funktion die
heißt irgendwie sound ja. Und dann haben die alle den dann
erben die alle diese Soundmethode und die kannst du
dann auch überschreiben. Ja also das das dann quasi dann
sagst du in deiner Hundklasse sagst du Sound kommt Bark raus
oder irgendsowas ja und in der in der Katze kommt irgendwie
miau und so weiter ja und in der in der so ist das ja so und in
der Animal Klasse würde man sagen OK ich in der animal
Klasse hab ich zwar die Funktion Sound aber die mach ich quasi
nur als Interface, ich will quasi zwingen, dass alle die von
mir erben mal irgendwie nen Sound n Tier sound irgendwie
machen können ja. Da kann ich zum Beispiel sagen,
und das sind jetzt alles noch so Konzepte, da können wir nicht
alles drauf eingehen, aber ich kann dann sagen, ich hab das ist
Abstraktion, ich hab einfach nur n Interface Sound und ich zwinge
alle, die mich erben, das kann man auch angeben, wird dann ne
pure abstrakte Funktion quasi. Ich zwinge alle, dass die dieses
Interface implementieren müssen. Ja und je nachdem was ich dann
bin für nen Animal für nen Teal quasi später im Code ja mach ich
dann halt irgendwie miau oder oder ich Belle oder irgendwas
ja. Ich, ich, ich mein, man kann ja
mal, das ist n schönes Bild, aber es hat so so wenig mit der
Realität zu tun, weil kein Mensch irgendwelche Jaus und
Animal ist irgendwie programmiert, das macht ja
keinen Sinn mehr. Ja tatsächlich hab ich das auch
gerade nicht gedacht, es steht aber trotzdem in allen
Lehrbüchern, das nervt total. Ja, aber ich wollt das, wollt
ich mal so sagen, Bill Bob bisschen abgenervt ne Scheiße,
ja tatsächlich, es steht das in den Lehrbüchern, deswegen kommt
es wahrscheinlich auch bei Deep Sea, Gon Tschechibity und so
raus. Wahrscheinlich, wenn du die
nämlich fragst, die die machen auch gerne gleich so n Animal
Dog und so weiter Beispiel was ich da irgendwie vorstellen
kann, ne, aber jetzt will ich noch eine Sache sagen und die
die liegt da jetzt immer auf diesem Level nicht man kann sich
es auch so vorstellen, wenn man verstehen will was ist
Vererbung, dann sagt man immer im Englischen sagt man das ist
eine ist Verwandtschaft, also das ist nicht das Wort ist also
ist eine, ja dann kann man immer so also ein Hund ist ein Tier.
Und deswegen hab ich Tier als Base klasse und dann erbt er es
ja. Das kann ich natürlich, ich
könnte sagen ne Statistik ist ne Mathematik so ja dann dann hab
ich das halt geerbt, ja. Burkhard war das alles zur
Färbung. Du hattest glaub ich noch was
anderes erwähnt. Genau.
Es hat sich rausgestellt, dass dieses ganze Vererbungsgedöns
gar nicht so cool ist. Ja, wenn ich den Code
strukturieren will, warum sich das rausgestellt hat, ist jetzt
auch noch mal ne eigene Folge, aber.
Also ich kann halt nicht, ich kann halt ganz schwer nur
teilweise vererben. Ja das so ein Problem ist.
Ich muss halt echte Realitätsdinge so schaffen zu
abstrahieren, dass ich halt nicht zu viel und nicht zu wenig
Erbe vererbe und dann auch vor allen Dingen für die ganzen
Baseklassen nicht und es stellt sich raus, dass es gar nicht so
einfach ist. Ja, denn das hat man schon sehr
früh festgestellt, es gibt nen ganz bekanntes Buch, 1994
erschienen Design per Dance Elements of reusible Code.
Besser bekannt als das Gang of Four Boof Goof.
Ich weiß gar nicht mehr, ob das heute noch so bekannt ist, aber
so in in in meinem Alter war das irgendwie damals so ne
Pflichtlektüre, das war so ne Bibel, ja, weil es kam halt
diese objektorientierte Programmierung auf und es kam
vor allen Dingen C plus plus auf, das war das war so der
Auslöser C plus plus halt ne unglaublich mächtige Sprache und
C plus plus implementiert diese gesamte Objektorientierung.
In allen Facetten komplett durch.
Ja, da kannst du alles machen mit abstrakten Klassen voll
abstrakten Klassen, Vererbung und so weiter und sofort und man
war n bisschen überfordert und es und dann gab es dieses Buch
von diesen 4 sehr guten Softwareentwicklern, die
versucht haben, das mal n bisschen auf zu, ja n bisschen
auf zu aufzuschreiben, was man überhaupt jetzt damit alles
machen kann. Ja, also selbst wir sprechen ja
jetzt gerade n bisschen drüber, das ist n dickes Buch, was quasi
sehr. Abstrakt, einfach nur mal
erkennt gegeben diesem einen Konzept, dass ich dieser
Funktion noch hinzufüge, dass ich so ne Art Templates hab und
Instanzen von diesen Templates und wie ich jetzt mit diesen
Instanzen von den Templates, von denen ja viele existieren
können, zu Runtime, wie wie kann ich die jetzt in Beziehung
setzen, was mach ich damit alles da ist?
N Riesen Buch entstanden, ne, aber Fazit von diesem Buch war
nutzt mal lieber nicht so viel Vererbung, das führt ins Chaos
ja und so n bisschen die Grundessenz war, dass es nämlich
sehr kompliziertes. Wenn man andauernd nur vererbt,
dann fängt man nämlich an, beim Design von den Klassen sich n
Bein abzubrechen, weil weil ich ich hab dann ganz oft passt das
nicht so ganz genau. Ich erb dann zu viele von meiner
von meinem parent Funktion, die ich eigentlich gar nicht
brauche. Ja und dann wird es
unübersichtlich und ich sind es quasi wenn ich als Programmierer
ne sehr tief geerbte klasse habe, dann hab ich irgendwie so
n riesen Stapel an Funktionen ne weiß ich auch nicht mehr welche
ich nehmen soll uns fort ja. Und es wird relativ starr und
man kann es nicht mehr so einfach durch die Gegend ändern,
wenn man, wenn man mal größeres refactoring macht, dann muss ich
irgendwie so ganze Hierarchiebäume und so weiter
aufbrechen und muss auf einmal in ganz vielen Stellen Code was
ändern und weil alles irgendwie in so einer riesen Hierarchie
zusammenhängt, hab ich so riesen restrukturierungsgedöns und so
weiter und man hatte damit, das war früher wirklich Riesenthema
so n so n klassendesign wenn ich mir das einmal überlegt hab, so
das ist nicht mehr so einfach zu refaktorisieren wenn ich den
Code einmal eingeschrieben hab war es und dann große Große.
Große, große Sachen. Ja.
Wenn ich mir aber was falsch überlegt hab, dann hab ich
richtig designprobleme in meinem Code, das ist so n bisschen wie
wenn ich irgendwie im Hotel irgendwie den den Zulieferer LKW
dann irgendwie in die 2. Etage geplant hab und der muss
halt immer irgendwie erstmal das Parkhaus hoch und dann oben
zuliefern oder irgend so was das das ist Blödsinn, das Krieg ich
nicht so schnell nicht mehr weg. Ja und diese Vererbungssachen
führen dazu, dass ich dann diese starren Strukturen hab, die ich
nicht mehr schnell ändern kann ne und man sagt die Komposition
Composition im Englischen. Ist das überlegenere Pattern ne
so jetzt kurz, was heißt Komposition?
Ne jetzt? Wir haben ja verschiedene
Klassen, sehr viel verschiedene Klassen und wir haben
verschiedene Instanzen davon jetzt kannst jetzt kann ich wenn
ich während ich sage wenn ich jemandem Erbe, dann bin ich
jemand, ja wenn ich meine statistikklasse bin, dann bin
ich ne matheklasse wenn ich von der Erbe ich könnte aber auch
sagen Ich heiße jetzt statistics und ich Erbe von gar keinem ich
Erbe nicht ich habe einfach die Klasse statistics.
Jetzt brauch ich bestimmte Mathefunktionen, aber nur ganz
bestimmte. Ja, und in der Maß Class sind
vielleicht 120 Mathefunktionen ne daraus brauch ich jetzt 3.
So jetzt sag ich mir ich hab eine Mathe Instanz ist noch
dabei ja und das nennt sich Komponieren ist jetzt und denn
ich denn eine innerhalb einer Klasse jetzt wird es n bisschen
quer kann ich auch wieder mit Instanzen arbeiten von anderen
Klassen ne und ich kann zum Beispiel sagen ich kreiere die
dann, dann bin ich quasi auch. Also ich kann quasi ja auch
dieses New, was ich vorher gesagt hab, das kann quasi auch
in der Klasse funktionieren in der Instanz.
Ja und ich hol mir ne neue Klasse Mathe oder ich hol mir
einfach nur ne Referenz rein von einer die es vorher gab.
Ja das macht man zum Beispiel oft, man kann zum Beispiel sagen
im Konstruktoraufruf von der Statistics bekomme ich schon
eine Instanz der Matheklasse mit, dann hab ich eine
Matheklasse, das ist der große Unterschied, entweder.
Bin ich eine Matheklasse, dann hab ich sie geerbt oder ich hab
eine Matheklasse. Dann hab ich dann hab ich so ne
Instanz von so einer Matheklasse wie auch immer die aussieht in
der Hand. Ja und jetzt ruf ich quasi
einfach wieder maß Punkt und jetzt ruf ich quasi nur diese
Funktion auf, die ich gerade brauche für meine Statistiks ja
und das können dann quasi in meiner Statistikklasse andere
sein als zum Beispiel jetzt in dieser Bildverarbeitungsklasse,
die ich vorher hatte, da brauch ich vielleicht andere
mathefunktionen ne für den. Endanwender jetzt aber von
meiner Statistikklasse sieht die Sache viel sauberer aus, weil
wenn der sich jetzt anguckt Geräte mir noch mal bei deinem
Fall ne wo du im IDE bist und du gehst jetzt auf die
Statistikklasse und drückst jetzt Punkt und jetzt kommt das
Autocomplete. Ja wenn ich jetzt die
Matheklasse komponiert habe, dann hab ich das ja privat
gemacht, dann hab ich jetzt ganz sauber nur die Interfaces, also
nur die Funktionen die jetzt für meine Statistikklasse relevant
sind und die erwarte ich ja quasi auch als Entwickler, wenn
ich die Statistikklasse benutze, ja.
Was ich aber nicht habe, es sind die ganzen Mathe raffel
Funktionen will ich ja auch nicht aufrufen wenn ich
statistics habe habe ich die aber geerbt, die Matheklasse ja
dann drücke ich wenn ich auf Punkt auf ne Idee drücke, dann
sehe ich alle Funktionen ja auch die von der Matheklasse und die
von der Statistics Klasse, das heißt das Enkapsulieren
funktioniert noch viel effizienter wenn ich gar nicht
so viel Erbe oder wenn ich nur selten Erbe, dann wenn ich es
wirklich wenn wirklich auch alle Funktionen die ich Erbe sehr
relevant sind für meine eigene Funktionalität, ja auch für den
Nutzer der mich benutzt ja. Und wenn das aber nicht so ist,
dann dann hab ich quasi trotzdem eng kapseliert und Zugriff auf
gekapselte Funktion von der anderen Klasse.
Aber Schütte das quasi nicht in mein Public Interface rein.
Ja bleibt halt sauber versteckt. Ja stellt sich heraus, dass das
irgendwie andauernd benutzt wird, ja.
Das sieht ja viel, viel sinnvoller.
Ja, also ich hab ja viel weniger Kram, den ich einfach nicht
brauche dabei letzten Endes und auch schon vorübersichtlichkeit
dann irgendwie. Stimmt ja, wenn man sich es ganz
genau anguckt, gibt es ja und es gibt.
Pro und Contra für beides. Aber die Daumenregel ist im
Schnitt. Guck mal ob du das mit
Composition machen kannst da weil wenn man anfängt mit diesem
ganzen Kram ist es total schwierig, man hat noch kein
Gefühl wie wann nehm ich was und wie muss ich das machen.
Das ist also gerade für juniorige Entwickler im
objektorientierten Programmieren ist ist gar nicht so einfach
rauszufühlen was mach ich hier am besten wie das ist so man
kann es echt vergleichen mit einer normalen Architektur, man
muss n bisschen Erfahrung haben, man muss n bisschen was gesehen
und gemacht haben bis man rafft wie trenn ich das am besten auf
so ja. Ich will mal gerade noch ein
Beispiel aus dem Leben geben, da kann man sich das Mal vorstellen
mit diesen ganzen Haritans und diesen ganzen Patterns.
Ja, wir nehmen jetzt mal 1 aus unserem Leben, sagen wir mal,
wir haben ne, wir widerspiegeln ne ne ne Industrieunternehmen ne
Factory, ja und dann könnten wir zum Beispiel sagen wir haben ne
ne ne Klasse, die heißt Factory und da sind so Methoden drin wo
da steht erstmal die Firma drin wie heiße ich und so weiter wie
groß bin ich, wieviel Quadratmeter oder was weiß ich
so keine Ahnung ja und dann könnte es sowas geben wie ne
Production line. Weil ich, was ich, was ich jetzt
im Code aufbauen will, ich will quasi, ich will quasi Factory
irgendwie managen können, ne, aber grundsätzlich schreib ich
ja nur ich schreib das ja nicht für jede einzelne Factory will
ich jetzt n Code machen, sondern für alle Factory also hab ich ne
klasse Factory wo ich erstmal so grundsätzliche Daten speichern
kann, dann könnte ich ne Klasse haben die heißt Production Lion
und jetzt kann ich sagen ne Factory hat Production Lines
also der Factory gehören die Production Lines ja die man man
sagt das ist jetzt ne Komposition ne das heißt.
Würde ne Instanz einer Production Line in die Instanz
der Klasse Factory einklemmen? Ja, und dabei kann ich jetzt
sogar noch sagen, das können ja mehrere sein, das ist auch das
schicke, ja, ich kann sagen eine Factory Instanz hat jetzt
mehrere Instanzen unterschiedlich konfiguriert von
Production Lines ja 12357 ja und so weiter und er nennt es jetzt
eine Owens composition, weil die Production line.
Für sich alleine macht keinen Sinn.
Ja, Production Line alleine lebt nicht ohne Factory.
Jetzt kommt das zweite Beispiel, die Production Line nutzt
Maschinen ja und jetzt auch wieder ich könnte ne Maschine ne
Presse haben, ich könnte ne CNC Maschine haben, ich könnte so n
so n so n so n so n Laufband haben und so weiter ja die
Maschinen aber sind jetzt anders komponiert und das hat das mit
der Lifetime jetzt zu tun, das ist noch mal was ich sagen will
zu diesen Patterns dann brechen wir das dann auch ab an der
Stelle aber so ne Maschine kann ja ganz alleine stehen ja.
Die braucht keine, die braucht weder die Factory noch die
Production Line. So richtig kannst du irgendwo
hinstellen, kann er noch irgendwo gebaut worden sein und
so weiter so und deswegen hat die Production Line nutzt eine
Maschine, also der Lebenszyklus von der Maschine, der wird nicht
von der Production Line bestimmt, die Production Line
wird nicht die Maschine instanzieren ja, denn das ist
auch noch das komplexe Gerät bei dem Ganzen den ganzen Kram, weil
ich hab ja gesagt und das kommt immer nicht vor, das mag ich
nicht so, das kommt immer nicht vorbei diesen.
Wenn man das so liest von außen, ja, es kommt nie das Wort
Lebenszyklus vor. Ich würde diesen 4 Pillars, wie
sie immer so heißen, Abstraction encapculation, Harritons and
polymorphism, den würd ich auf jeden Fall n fünften dazu geben
und den würd ich weiter nach oben schieben von der
Wichtigkeit, das ist Lifecycle ja denn so n Objekt lebt also ne
Funktion nicht ne Funktion rufst du auf, die arbeitet ab und gibt
dir n Return wert, die speichert ja auch keine Daten zwischen die
sind dann verloren ja alles bleibt.
Lokal in dieser Funktion aber so ne Instanz lebt halt und da hat
n Start n State wie man sagt über die Lebenszeit auch
verändert werden kann und irgendjemand muss das
Konstruieren, das Vieh, ja und irgendwer wird es auch
destruieren und da, wenn es nicht mehr gebraucht wird
weggeschmissen, ja und man muss sich halt überlegen, wenn man
jetzt, wenn es alles in Klassen und Objekten sind was so moderne
Software ist, ja, da gibt es nichts anderes mehr, es gibt
keinen freien Code mehr, es gibt alles in Klassen und Objekten
abgehandelt, ja. Da muss man sich halt auch
überlegen, welche Instanz erzeugt welche andere, also wem
gehört da wer und wer, wer sorgt dafür, dass es wieder weg ist
und so weiter ja, denn es kann ja auch, es können ja Sachen
auch kommen und gehen in so einer Runtime.
Ja du musst da auch dich darum kümmern, dass es wieder abgebaut
wird und nicht irgendwo rumeiert und so weiter ja das das ist
relativ komplex, ja. Das klingt furchtbar komplex,
irgendwie so aber. Das ist makaber, komplex sogar.
Ja, und es gibt extra, das ist auch noch was, es gibt sogar
dann, um, um das irgendwie mal aufzumalen.
Und das Schwierige ist ja auch noch, dass es ne, dass es 2
Lebenszeiten gibt. Wenn du das jetzt Code
hinschreibst, dann gibt es ja quasi das Bild von dem, wie du
es aufgebaut hast und dann zur Runtime, das muss man sich dann
im Kopf vorstellen, dann wird ja quasi Leben eingehaucht und
existieren viele Varianten von diesen Dingern, die sind
irgendwie verwoben. Ne, das ist komplizierter als ne
relationale Datenbank was da alles passiert.
Ja und da gibt es ne Sprache, die heißt UML Unified Markup
Language. Da kann man das quasi mal
aufmalen. Wieso Klassenzugehörigkeiten
sind das sind, das hat vielleicht unsere Zuhörer schon
mal gesehen, da sind so boxen und dann, so gibt es so Pfeile
mit verschiedenen, und das ist ganz wichtig, was wir mal
angucken, sind die Pfeile ausgefüllt oder sind die ool und
fangen die an mit einer Raute oder nicht und so weiter und da
gibt es, ich will das Mal andeuten, da, da wird das quasi
alles ausgedrückt, ob irgendwas voneinander erbt oder ob
irgendjemand jemanden hat oder ob jemanden den Life, den Life
Cycle von jemandem bestimmt oder nicht und so weiter.
Da kann man so n Fettes UML Diagramm zeichnen von seinem
ganzen Code ja oder zeichnen lassen oder so weiß ich nicht.
Ja dann sieht dann dann merkt man manchmal, wenn man sich das
Aufmalt irgendwie wie komplex der ganze Kram ist oder ja o.
K kann man wahrscheinlich schon sich irgendwie auch erstellen
lassen mit irgendwelchen Tools. Nein kannst.
Du, die mittlerweile auch erstellen lassen?
Ja genau. Aber jetzt, du hattest jetzt
noch das Poly Morphism erwähnt, aber bist natürlich drauf
eingegangen, ne? Ja, das Poly Morphism ist.
Ich benutz das zum Beispiel selber gar nicht so oft.
Das ist so n bisschen. Ach das, das kommt so n
bisschen. Aus der Sucht danach, dass man
also in diesen kompilierten Sprachen wie Java und C plus
Plus, da hast du immer Schwierigkeiten, überhaupt auch
mit Code teilen innerhalb deiner eigenen Software zu sprechen.
Ja, und das gleich zu ziehen, ja, also Polymorphism heißt
halt, dass bei der gleichen Funktion.
Verschiedene Ergebnisse rauskommen, je nachdem, wer du
bist als geerbte Funktion. Ich mach das jetzt noch mal an
diesem blöden Beispiel, Animal und und und und Dog und Cat und
so weiter klar ja, das ist nämlich dieses Beispiel was
immer kommt. Also du hast in der Animal Class
hast du zum Beispiel genau diese Funktion, irgendwie Sound oder
Irgendsowas, also das Tiergeräusch ja und du willst
später, wenn du irgendwer macht für dich diese Animals ja und
der macht aber nicht n Animal sondern der macht ne Cat.
Und er macht nen Dog und er macht nen Fisch oder irgend
sowas. Ja und aber in also auf der
Abstraktionsebene hältst du aber eigentlich nur n Animal in der
Hand. Dich interessiert jetzt in
diesem Stück auf der Abstraktionsleihe wo du gerade
bist nur das Animal und dann hast du die Funktion Sound, das
ist dein Interface, das wurde dir versprochen.
Ja Sound gibt es ja, weil auf der Base Class Animal gibt es
halt die Funktion Sound ja so und je nachdem was du jetzt
gerade in die Hand bekommen hast.
Macht halt Sound entweder Miau oder Bark oder blub, blub oder
irgend so was für den Fisch so ja das ist ein ganz bescheuertes
Beispiel, weil das weil man kriegt es nicht, also ich kriege
selber nicht im Kopf irgendwie auf irgendwas sinnvolles mit dem
Kot gebügelt. So und deswegen ist mir gerade
während ich das erzählt hab, hab ich überlegt gibt es ein
besseres Beispiel, ich sag 1 aus unserer Welt.
Wir haben zum Beispiel, Wir haben ja diese Low Code
Anwendung geredet, weißt du ja ne.
Und du hast das hab ich schon mal gehört.
Ja genau, also ja, das ist schön so.
Und dann, wir können ja unsere Nutzer haben ja diesen Frontend
Bilder da und die ziehen, die ziehen da ja irgendwie Buttons
drauf und ne Form und Datagrid und n Icon oder was weiß ich so
ja so und bei mir ist das alles n Widget also diese Dinger sind
von der von der Basisklasse her mal ein verdammtes Widget, ja.
So, und was die alle können müssen und was ich auch können
muss im Code, ich muss an irgendeiner Stelle im Code, das
ist sehr hoch am abstraktionslevel muss ich jetzt
sagen, so pass mal auf, jetzt render ich diese ganze Seite hin
ja also muss ich sagen für alle Widgets ja Ruf auf die
Renderfunktion ja, dabei ist mir völlig wurst was das jetzt
rendert. Ja an der Stelle ich will nur
erst ich muss dir irgendwo mal muss ich ja mal die Anweisung
geben, rendert jetzt mal alle durch ja und dann nimmt er die
nächste Page in die Hand gehst du auf die nächste Page, dann
musst du ja wieder alle rendern ja.
Da hab ich also so ne Art vor Loop für alle Widgets, die auf
dieser Page sichtbar sein sollen.
Widget, Punkt, Render, Widget, Punkt, Render, Widget, Punkt,
Render, Widget, Punkt, Render und diese Widgets sind alles
verschiedene Klassen von der basisklasse Widget, aber
tatsächlich ist es n Button n datagrid Form oder Irgendsowas
ja und aber das Widget sagt Es gibt hier ne Funktion Render und
ihr habt die alle zu implementieren Render ja.
Und das Render auf dem Button Rendert mir halt n Button und
das die Renderfunktion auf dem Form, die rendert halt das was
ne Form sein soll hin. Ja so und deswegen ist das
sinnvoll weil du musst im Code ganz oft auf einer sehr hohen
Abstraktionsebene mit Objekten umgehen weißt du so ich ich ich
ich ich weiß an der Stelle gar nicht an der Stelle wo ich im
Code bin geht es nur darum den Scheiß einmal runter zu rendern,
ja da da interessiert mich das aber nicht was das ist.
Und, und wer das gemacht wurde, das passiert zu einem anderen
Zeitpunkt. Wenn du nämlich Gerrit, das
kannst du jetzt auch noch vorstellen, wenn du nämlich da
jetzt zum Beispiel einen neuen Button ziehen willst, dann
drückst du ja oben auch bei dem Auswahl Drop Down auf Button und
dann klickst du noch mal in das Frontend, dann wird jetzt ein
Button hergestellt, an der Stelle kreierst du eine Instanz
von der Klasse Widget, die aber Button ist und das ist
Polymorphese mehr. Und jetzt vereinheitlicht das
Interface. Und jetzt, wenn wenn jetzt unser
neuer Entwickler zum Beispiel nicht einen Button machen muss,
sondern was weiß ich einen centi Chart oder irgendwas, dann sage
ich ihm, pass mal auf, wenn du einen centi Chart machst.
Hier guckst du mal Widget, das sind die Base Funktionen, die
musst du alle implementieren und wenn du die sauber implementiert
hast, dann ist schon fertig, dann funktioniert schon der
restliche Code ja weil der einfach nur diese dieses
Interface quasi ausführt und wenn du das ordentlich gemacht
hat funktioniert es einfach. Ist n besseres Beispiel als die
blöde Runde Katzen. Ja, jetzt musst du mir aber
zwischendurch auch mal n Satz sagen lassen, um das mal so
halbwegs versuchen zu rekapitulieren, ja, ist das
quasi unmöglich als als nicht Softwareentwickler.
Ich hab auch quasi wieder vergessen was ich sagen wollte,
aber ist Grad der Groschen gefallen als du mit dem Brennern
kamst und du sagtest, dass Methoden, also unterschiedlich
sich verhalten können, letzten Endes, je nachdem wo sie oder
wie sie aufgerufen werden oder in welchem Kontext und rendern
hast du jetzt genommen, weil der eine Rendert Halt n Button hin
und das nächste Rendert ne Tabelle hin.
Und das nächste Render hat irgendwie n Chart hin, aber es
ist immer die Funktion render. Genau mehr hab ich nicht zu
sagen. Ja, das ist auch nicht das
Thema, wo man in so ne riesen Diskussion kommen kann, wo man
das eigentlich ist das so ne Erklärbeerfolge heute.
Also ich kürz das mal ab, wir haben schon n bisschen länger
gesprochen, also versuchen noch mal so ne Summary zu machen,
also dieses ganze objektorientierte programmieren,
das ist im Prinzip ja ne Idee wie Entwickler selber ihren Code
so strukturieren können. Dass er krass wiederverwendbar
wird und einfach zu durchsehen und zu verstehen auch für vor
allen Dingen andere Nutzer, also für einen selbst sowieso, ist es
auch mal gut, wenn man sich selber organisiert, aber und
und. Und das vielleicht noch mal
gesagt an der Stelle, unsere haben ja auch oft schon gesagt,
Open Source, Bibliotheken und so weiter und sofort, ja, was sind
denn softwarebibliotheken? Bibliotheken sind Anhäufungen
von genau diesen Klassen. Ja, die Methoden haben, die
irgendwas beschreiben und sofort ja.
So wird das normalerweise gemacht.
Ja, und dann, wenn ich ne Bibliothek benutzen will von
jemandem, den ich gar nicht kenne, also der sie irgendwie
geschrieben hat, will aber verstehen was los ist, hat sich
herausgestellt, dass das objektorientierte Programmieren
n cooler weg ist, um es relativ gut und relativ sicher in meinem
Code zu nutzen, ne? Und es schien mir jetzt auch
sehr, ich weiß nicht, irgendwie realitätsnah zu sein oder sowas.
Also die ganzen Beispiele, die du jetzt so gemacht hast, außer
das vielleicht mit den Tieren. Und ich erinnere mich einfach an
die Factory und die Productionline und so weiter
wirkt ja so, als würde man versuchen irgendwelche echten
Dinge realen Dinge auch abzubilden.
In Klassen wiederum und Objekten.
Ja, genau, möglicherweise ist die ja genau.
Also es gibt ja so n Buzzword in digitalen Zwillingen so, das ist
irgendwie so für die für die nicht Programmierer so ne, man
sagt ja irgendwie, das ist die digitale Abbildung von der
Maschine oder Irgendsowas. Das ist, wenn du so eine Klasse
hast. Aber tatsächlich ist es
andauernd so, dass Entwickler alle möglichen reellen Dinge mit
sehr guten Namen versehen und versuchen, die ganz das ganze
reelle Problem was ich habe, was ich an ne Software gießen
möchte, genauso widerzuspiegeln. Ja, das sind im Prinzip alles
Mini digitale Zwillinge von Miniproblemen oder Aspekten von
meinem Gesamtproblem was ich hab und und der deren Beziehung
untereinander widerspiegeln dann hoffentlich halt auch die die
Realitätsbeziehung hast du, ich hab bei der Factory re
production nein gesagt. Also normalerweise musst du auch
deinen Code durchgehen können mit den ganzen Klassen, die du
hast und diesen ganzen Patterns und den Vererbungen und und und
Zusammenhängen und Relationen und musst dir das quasi vorsagen
können und es muss im besten Falle zur Realität passen, wenn
es nicht zur Realität passt, dann hast du, dann hast du bei
deinem objektorientierten Design irgendwo n Fehler gemacht und
der der tut dir meistens relativ stark weh, dann irgendwann ne
das das merkt man dann wenn man dann die Anwendung größer wird,
ja. OK, dann noch mal von mir
vielleicht letzte Frage, du hast jetzt immer C plus plus erwähnt
und Java glaub ich als als objektorientierte
Programmiersprachen. Ich hab jetzt immer noch nicht
so ganz verstanden was jetzt zum Beispiel Node JS wäre oder oder
Java Script du benutzt es ja auch so als also
objektorientiert oder nicht. Ja, alle modernen Sprachen
unterstützen Objektorientiertes programmieren.
Punkt. OKOK du kannst damit auch
objektorientiert programmieren. Ja, so der Unterschied ist, dass
das C plus plus ne kompilierte Sprache ist.
Und zum Beispiel Python und Java Script und so weiter sind
interpretierte Sprachen. Du bist mit C plus plus noch in
viel krasseren Gefängnissen unterwegs, was die Aufrufbarkeit
und die Interoperabilität von Funktionalität innerhalb deines
Codes angeht. Deswegen ist in C plus plus das
auch erstmal so richtig, deswegen war das auch ein
Durchbrecher ja man, früher war es gar nicht so einfach
irgendwie Code. Trocken also don't repeat
yourself. Ja, also den Code so zu
organisieren, dass ich ihn halt überall irgendwie wieder gut
aufrufen kann. Ja, weil das das heißt ja, dass
ich quasi Interfaces haben muss, die sich wiederverwend
Wiederverwendbarkeit heißt immer ein gewisses Maß an
Standardisierbarmachung ja, muss ich ja erreichen, ja, und das
ist gar nicht so einfach in diesen Strictly Type
kompilierten languages wie C plus Plus und Java, es ist
sowieso viel einfacher in Python und Java Script, aber.
Es wird auch genutzt. Objektorientierte Programmierung
und Python manchmal nicht so oft.
Python hat manchmal einfach so n Skript was runterläuft so das
und dann dann weiß man auch schon, dass man es irgendwie gar
nicht so viel braucht, weil es relativ irgendwie tack, tack,
tack, tack, Tack irgendwas abgehst ja führt ein Pfeilformat
in n anderes über, da brauchst du jetzt auch nicht riesen
Objekte oder irgendwas basteln, ja sobald du irgendwie n
bisschen mehr machst in der Anwendung so und merkst du
sofort wenn du das nicht irgendwie aufteilst wenigstens
in Funktionen so n bisschen. Aber viel besser noch gleich in
in Klassen und so weiter da bist du sofort verloren, weil du
einfach spaghetticode dahin donnerst.
Das ist nicht mehr erwartbar und nicht mehr hinterhinbar.
Ich glaube, das ist so ein Konzept, was auch nicht mehr
umgeworfen wird gefühlt, man hat das mal.
Ich glaube, man hat da den Goldenen, die Goldene Goldene
Mitte gefunden, ich glaube, alle, alle sehr großen oder
mittelgroßen Anwendungen sind irgendwie objektorientiert
programmiert, aufgeschrieben heutzutage.
Im Detail nach Programmiersprache ändert sich
das so n bisschen. Wie wie genau geht Vererbung?
Kannst du von mehreren Vererben nicht so weiter da.
Du kannst dir ja vorstellen, da gibt es zig theoretische
Möglichkeiten wie du damit umgehen kannst.
Die sind alle so n bisschen unterschiedlich, aber am Ende
das objektorientierte Programmieren hat sich
durchgesetzt. Über alle modernen Sprachen
hinweg ist der Standardweg, deswegen muss man es einmal
verstanden haben. Was ist ne klasse und was ist so
ne Instanz und was sind Instanzmethoden und
klassenmethoden und so weiter so deswegen würde ich einfach n
bisschen durchgehen. Ja, mir hat das schon auch viel
Background noch zu dem gegeben, zu unserem Lowcode, zu letzten
Endes, wo, wo das ja auch Anwendung findet, also die
Konzepte der objektorientierten Programmierung, ohne dass man
programmieren muss. So wär das, hat sich das da mal
anzugucken, kann das auch zu hören.
Das hilft auf jeden Fall für für alle diejenigen, die jetzt
tatsächlich nichts weglassen, so wie ich.
OK, cool, Burkhard, gibt es da noch sonst was zum Thema OOP
bestimmt noch ne ganze Menge, ne.
Aber ja, ich glaube auch wahrscheinlich auch n paar
Sachen vergessen. Da gibt es irgendwann noch mal
ne Spezialfolge oder so. Ich glaube für den Moment haben
wir haben wir ganz gut drüber gesprochen glaub ich passt.
Gut, dann machen wir n Deckel drauf.
Danke Burkhard und danke Euch fürs Zuhören.
Tschüss von der Ostsee. Einfach komplex wird präsentiert
und produziert von Heiseware. Wir freuen uns auf deine Fragen
und deinfeedbackanpodcasts@heiseware.com
vielen Dank fürs Hören dieser Folge bis Dienstag in 2 Wochen
und Tschüss aus Hamburg.