Objektorientierte Programmierung (OOP) #82

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.