[0:01] Hallo und herzlich willkommen zum Anwendungsentwickler-Podcast, dem Podcast rund um die Ausbildung zum Fachinformatiker für Anwendungsentwicklung.

[0:10] In dieser Episode gibt es die erste Lernzielkontrolle zum Thema Objektorientierung. Viel Spaß!

[0:20] Hallo und herzlich willkommen zur 43. Episode des Anwendungsentwickler-Podcasts.

[0:26] Mein Name ist Stefan Macke und heute beginnen wir mal mit meiner kleinen Reihe der Lernzielkontrollen rund um das Thema Objektorientierung.

[0:34] Da gibt es einiges zu zu fragen und zu wissen, vor allem als Prüfling.

[0:38] Und deswegen fange ich heute mal an mit der kleinen Reihe hier.

[0:41] Wir fangen erstmal mit ein paar grundsätzlichen Sachen an rund um die Objektorientierung, Klasse, Objekt und so weiter.

[0:46] Und dann schaue ich mal, wie lang die Reihe dann im Detail wird.

[0:50] Also mindestens ein, zwei, drei Episoden werde ich da auf jeden Fall noch zu machen können, weil man da ja noch einige Begrifflichkeiten auch kennen muss.

[0:56] Und weil es auch letztlich eines der zentralen Prüfungsthemen ist, was auch gerne häufig in der mündlichen Prüfung, im Fachgespräch abgefragt wird, weil man da halt einfach so schön viel zu fragen kann.

[1:06] Und auch auf verschiedene Arten und Weisen fragen kann und hintenrum und gucken, ob das Wissen da ist und ob es wirklich tiefergehendes Wissen ist und so weiter.

[1:13] Von daher eines meiner Lieblingsthemen, was ich auch relativ häufig mit meinen eigenen Azubis immer wieder durchkaue, weil ich halt weiß, dass es so ein wichtiges Thema ist.

[1:20] Nicht nur für die Prüfung, natürlich auch für die Berufspraxis. Das ist ganz klar.

[1:24] In den meisten Sprachen, in denen wir heutzutage programmieren, ist Objektorientierung das beherrschende Paradigma.

[1:29] Und von daher sollte man sich auf jeden Fall auch sehr gut damit auskennen, gerade als Anwendungsentwickler natürlich.

[1:36] Ja, ich habe gesehen, es ist heute die 43. Episode. Letztes Mal war es die 42.

[1:40] Und ich habe natürlich völlig vergessen, ein kleines Jubiläum zu feiern.

[1:43] Richtige Informatiker feiern natürlich nicht bei der 50 oder bei der 100, sondern bei der 42. Ist ja völlig klar.

[1:49] Wer die 42 nicht kennt, wer nicht weiß, was dahinter steckt, dem empfehle ich dringend den Film oder das Buch Per Anhalter durch die Galaxis.

[1:56] Ich habe es nochmal in den Shownotes verlinkt.

[1:59] Ganz, ganz wichtig, denn es werden immer so viele Insiderwitze über die 42 gemacht.

[2:03] Ich glaube, auch als angehender Anwendungsentwickler sollte man wissen, was dahinter steckt.

[2:08] So, aber dann kommen wir mal zum Inhalt, nämlich der Objektorientierung.

[2:11] Da fangen wir mal ganz vorne an, nämlich was ist eine Klasse?

[2:15] Eine Klasse, das ist ein Bauplan für Objekte. So definiere ich das immer.

[2:20] Die Klasse und das Objekt, das sind zwei Begriffe, die sehr stark miteinander verbündelt sind, sage ich mal.

[2:26] Man kann eigentlich das eine nicht ohne das andere erklären.

[2:28] Wenn ich jetzt bei Null anfangen würde, würde ich eher mit dem Objekt anfangen.

[2:31] Denn ein Objekt ist eigentlich etwas, was ich auch jemandem beibringen kann, der noch nie prohamiert hat.

[2:35] Ich kann einfach sagen, jedes Ding der realen Welt ist ein Objekt.

[2:39] Also ich kann, wenn ich zum Beispiel in so einem Raum sitze, sagen, der Stuhl, der hier steht oder das Telefon, was da steht oder den Monitor, den ich vor mir habe.

[2:45] All das sind Objekte der realen Welt.

[2:47] Das bedeutet, wenn man mal genau guckt, was jetzt dahinter steckt, so ein Objekt, das hat gewisse Attribute, gewisse Eigenschaften.

[2:54] Und es hat bestimmte Funktionen, Attribute.

[2:57] Das wäre zum Beispiel so etwas wie die Farbe von meinem Monitor oder die Helligkeit des Monitors oder das Holz, aus dem der Tisch ist und so weiter.

[3:05] Und die Funktion, die so ein Objekt hat, das sind alles die Dinge, die ich mit diesem Objekt tun kann.

[3:10] Ich kann zum Beispiel den Monitor an- oder ausschalten.

[3:12] Ich kann den Tisch zum Beispiel bewegen oder zusammenschrauben.

[3:16] Oder ich kann die Tür öffnen oder alles, was man sich vorstellen kann, was man mit diesen Dingen eben tun kann.

[3:22] Und diese beiden Bestandteile, die beschreiben im Prinzip mein Objekt.

[3:26] Ich kann also, wenn ich mich in einem Raum befinde, in dem drei Monitore sind, durchaus sagen, ich habe hier drei individuelle, verschiedene Monitorobjekte.

[3:35] Aber, und jetzt kommt der Rückschluss zur Klasse, alle diese Monitore haben eine gewisse Gemeinsamkeit.

[3:41] Ich kann zum Beispiel sagen, alle Monitore haben einen Ein- und Ausschalter.

[3:44] Oder alle Monitore haben eine gewisse Helligkeit.

[3:47] Die kann für jeden Monitor unterschiedlich sein, für jeden der konkreten drei Monitore, die da stehen.

[3:51] Der eine ist vielleicht heller, der andere dunkler.

[3:53] Aber ich kann sagen, alle Monitore haben die Eigenschaft Helligkeit.

[3:57] Sie können je nach konkretem Objekt eben eine unterschiedliche Ausprägung annehmen, also unterschiedliche Werte aufweisen.

[4:02] Aber es gibt keinen Monitor, der keine Helligkeit hat.

[4:05] Das wäre irgendwie blöd, dann wäre es kein Monitor.

[4:08] Genauso wichtig ist eben der An- und Ausschalter.

[4:10] Das heißt, ich kann also sagen, jeden Monitor kann ich anmachen oder ausmachen.

[4:14] Wenn ich das nicht tun kann, ist es kein vernünftiger Monitor.

[4:17] Und so kann ich mir also über die gemeinsamen Merkmale und Funktionen, die solche Objekte aufweisen, quasi eine Klasse konstruieren.

[4:25] Und ich sage, wenn ich Objekte einer Klasse Monitor habe, dann bedeutet das, dass ich die mindestens mal an- und ausschalten kann und dass sie eine Helligkeit haben.

[4:33] Und damit habe ich jetzt genau die Sachen definiert, die wirklich jedes Objekt von dieser Klasse Monitor haben muss.

[4:39] Und wenn das eben nicht der Fall ist, dann ist es halt kein Monitor.

[4:42] Es gibt natürlich noch ganz andere Objekte, wie zum Beispiel ein Telefon.

[4:45] Meinetwegen, das kann ich vielleicht auch an- und ausschalten, aber es hat vielleicht keine Helligkeit.

[4:49] Dann würde ich halt eben eine Klasse modellieren und sagen, das Telefon hat den An- und Ausschalter oder hat auch vielleicht das Tastenfeld oder hat vielleicht eine Displaygröße oder was auch immer.

[4:58] Aber eben zum Beispiel keine Helligkeit.

[5:00] Dann wäre es halt eine andere Klasse mit anderen Eigenschaften und Methoden.

[5:03] Und alle Objekte dieser Klasse Telefon haben halt eben diese Gemeinsamkeit quasi.

[5:09] Und über diese beiden Dinge kann ich jetzt also versuchen, in einer objektorientierten Programmiersprache meine Welt, sage ich mal, abzubilden.

[5:16] Man sagt auch, die Domäne meines Programms bilde ich damit ab.

[5:20] Wenn ich jetzt zum Beispiel eine Software schreibe, die irgendwelche Monitore verwaltet, dann sollte die halt eben genau wissen, was sie mit so einem Monitor machen kann, nämlich an- und ausschalten.

[5:28] Oder es kann zum Beispiel die Helligkeit abfragen.

[5:30] Wenn ich eine Telefonsoftware schreibe, wäre es blöd, wenn ich eine Klasse Monitor habe, weil meine Software mit Monitoren gar nichts zu tun hat.

[5:36] Genauso ist es halt, wenn ich eine Software schreibe für eine Autowaschanlage.

[5:39] Dann sollte die vielleicht von dem Auto wissen, wie groß das ist.

[5:43] Weil zum Beispiel die Bürsten entsprechend an der Seite nur so dicht ranfahren dürfen, dass die Fenster nicht kaputt gehen.

[5:48] Eine andere Anwendung, die vielleicht den Autoverkäufer unterstützt, die interessiert aber vielleicht gar nicht, wie groß das Auto ist, sondern nur, wie teuer das ist.

[5:56] Oder zum Beispiel, wie hoch eine monatliche Rate wäre oder sowas.

[6:00] Das heißt, ich kann mich also entscheiden in meiner Software, welche Teile meiner Domäne ich tatsächlich abbilde.

[6:06] Eine Klasse oder ein Objekt in meiner Premiersprache ist nicht zwangsläufig eine 1 zu 1 Kopie der realen Welt mit allen Eigenschaften und allen Funktionen, die das bereitstellt.

[6:17] Das können wir nicht abbilden und das wollen wir auch nicht in unserer Premiersprache.

[6:20] Denn in unserem Programm wollen wir nur die Teile uns angucken, die wir auch wirklich brauchen.

[6:24] Also in unserem Beispiel würde ich eine Klasse Auto modellieren für die Waschanlage.

[6:28] Eben mit solchen Funktionen wie zum Beispiel gib mir doch mal deine Länge, Breite, Höhe und so weiter.

[6:33] Aber das interessiert mich überhaupt nicht in meiner Software, wenn es um die Autoverwaltung geht, um die Autovermietung meinetwegen.

[6:38] Da brauche ich halt an der Klasse Auto vielleicht eine Funktion sowas wie gib mir mal deinen Mietpreis.

[6:43] Ich habe also als Programmierer die Wahl, welche Attribute und welche Funktionen ich in meiner Software abbilde.

[6:50] Und das ist eben genau die zentrale Aufgabe, die wir als Entwickler haben.

[6:54] Wir müssen uns nämlich überlegen, welche Dinge wir denn jetzt abbilden.

[6:57] Wir wollen halt eben nicht alles, sondern wir wollen nur das, was wir wirklich brauchen.

[7:00] Das ist auch ein schönes Programmierprinzip.

[7:02] Jagni, abgekürzt Y-A-G-N-I.

[7:05] You ain't gonna need it.

[7:07] Und wir werden auf jeden Fall nichts programmieren, wovon wir nicht ganz sicher sind, dass wir es auch brauchen.

[7:11] Denn alles, was wir programmieren, müssen wir auch supporten, müssen wir pflegen, müssen wir eventuell refaktorisieren, mit schleppen und so weiter und so fort.

[7:18] Obwohl es eigentlich niemand braucht.

[7:20] Und das wäre natürlich sehr ungünstig.

[7:22] Wir wollen uns ja nicht umsonst Arbeit machen, quasi.

[7:25] Von daher überlegen wir uns am besten ganz genau, welche Attribute und welche Methoden wir dann tatsächlich programmieren.

[7:31] So, also kurz zusammengefasst.

[7:33] Ein Objekt ist ein Ding der realen Welt.

[7:35] Das hat Eigenschaften und Funktionen.

[7:37] Eine Klasse, das ist ein Bauplan für solche Objekte.

[7:39] Und die definiert alle die Attribute und Methoden, die eben alle Objekte dieser Klasse haben müssen.

[7:45] Dann gibt es für den Begriff Objekt noch einen anderen Begriff, der häufig benutzt wird.

[7:49] Und das ist der Begriff Instanz.

[7:51] Instanz ist nichts weiter als ein anderes Wort für Objekt.

[7:55] Es sind also völlig austauschbar und gleichwertig.

[7:57] Das werden wir später noch sehen.

[7:59] Wenn ich zum Beispiel eine Instanzmethode habe, kann ich die auch theoretisch Objektmethode nennen.

[8:03] Das ist genau das gleiche.

[8:04] Also nicht verwirren lassen, wenn ihr zum Beispiel in der Prüfung mit Instanz oder Objekt arbeiten müsst.

[8:08] Und ihr habt das in eurem Praxisalltag so nicht, sag ich mal, auf dem Plan.

[8:13] Es ist ein und dasselbe, was da gemeint ist.

[8:15] Es gibt keinen Unterschied.

[8:16] Instanz oder Objekt.

[8:17] Auf Englisch halt Object or Instance.

[8:19] Das ist wirklich genau das gleiche, was da gemeint ist.

[8:22] Wenn man das jetzt weiß, dann kann man sich auch überlegen, was das Wörtchen Instanzierung dann bedeutet.

[8:28] Die Instanzierung bedeutet nämlich, dass ich eine Instanz erzeuge.

[8:32] Oder mit anderen Worten, ich erzeuge ein Objekt aus einer Klasse.

[8:36] Und das macht man in den meisten objektorientierten Prämiersprachen mit dem Schlüsselwörtchen new.

[8:41] Das heißt, ich würde so etwas schreiben wie bei meiner Autowaschanlage.

[8:43] New Auto.

[8:44] Und dann bekomme ich ein neues Objekt von der Klasse Auto.

[8:48] Ich sage in den meisten Prämiersprachen, denn es gibt auch welche, wo das etwas anders aussieht.

[8:52] Da fällt mir zum Beispiel jetzt Ruby ein.

[8:55] Das ist zwar auch das Schlüsselwort new, aber es sieht dann ein bisschen anders aus wie in Java zum Beispiel.

[8:59] In Java oder C Sharp, da würde ich schreiben new Auto.

[9:02] Und in Ruby würde ich sowas schreiben wie Auto.new.

[9:05] Ist zwar das gleiche Wörtchen, aber es sieht ein bisschen anders aus.

[9:09] Okay, dann bleiben wir doch nochmal so ein bisschen bei unserer Instanz.

[9:12] Da hatte ich jetzt gerade schon gesagt, es gibt Instanzmethoden anscheinend.

[9:15] Es gibt auch Instanzvariablen.

[9:17] Und was ist das jetzt?

[9:18] Ich hatte gerade gesagt, Objekte definieren Attribute.

[9:21] Bzw. die haben eigentlich Attribute.

[9:23] Die Klasse definiert diese Attribute.

[9:25] Und wenn ich jetzt diese Attribute irgendwie speichern möchte in meiner Prämiersprache,

[9:29] dann brauche ich etwas, wo die Werte reingeschoben werden.

[9:33] Und das sind klassischerweise Variablen.

[9:35] Das kennen wir ja schon außer Programmierung.

[9:37] Und jetzt ist die Frage, wo hängen diese Variablen?

[9:40] Wenn wir an unsere Methoden zum Beispiel vom letzten Mal zurückdenken

[9:44] und wir definieren Variablen innerhalb unserer Methode,

[9:47] dann sind das sogenannte lokale Variablen, weil sie nur innerhalb dieser Methode gültig sind,

[9:52] ganz lokal auf die Methode bezogen.

[9:54] Eine Instanzvariable muss dem Namen zufolge aber in der gesamten Instanz gültig sein,

[10:01] also in dem gesamten Objekt.

[10:02] Das heißt schon mal, ich kann sie nicht in irgendeiner Methode definieren,

[10:06] denn die Methode hat ja ihren eigenen Block.

[10:08] Das kennen wir noch aus einer der letzten LZKs.

[10:10] Und die Instanzvariable wäre dann eben nicht außerhalb dieses Blocks gültig,

[10:14] also nicht im gesamten Objekt.

[10:16] Das bedeutet, wir können sie eigentlich nur an einer einzigen Stelle definieren,

[10:19] nämlich auf der Ebene der Klasse.

[10:21] Wenn wir also mal in den Code schauen, wenn wir sowas schreiben wie class Auto,

[10:25] geschweifte Klammer auf, damit öffnen wir den Block dieser Klasse.

[10:28] Und wenn ich jetzt da drin irgendwo eine Variable definiere,

[10:33] dann wird sie zur Instanzvariable.

[10:35] Denn die wird dann in dem gesamten Objekt nachher gültig und verfügbar sein.

[10:39] Bedeutet insbesondere, ich kann sie aus jeder Methode ansprechen.

[10:42] Bei einer Instanzvariable ist es übrigens auch ganz egal, wo ich sie definiere.

[10:47] Ich kann sie also zu Beginn einer Klasse hinschreiben.

[10:50] Ich kann sie auch ganz am Ende der Klasse hinschreiben.

[10:52] Das ist völlig wurscht.

[10:53] Trotzdem können alle Methoden der Klasse darauf zugreifen,

[10:56] egal ob die Methode vor oder nach der Deklaration der Variablen programmiert wird.

[11:02] Eine Instanzvariable ist nun also eine Variable, die an einer konkreten Instanz hängt

[11:07] und danach auch eben einen individuellen Wert für jedes Objekt beinhaltet.

[11:12] Schauen wir uns nochmal diesen Monitor von eben an.

[11:14] Da hatte ich gesagt, ich habe drei Monitore in meinem Zimmer stehen.

[11:17] Jeder ist unterschiedlich hell.

[11:19] Das heißt, die Klasse Monitor definiert eine Variable,

[11:22] sagen wir mal der Einfachheit halber ein Int Helligkeit.

[11:25] Jetzt haben wir aber diese drei verschiedenen Objekte.

[11:27] Die können natürlich in dieser Variable jetzt ganz unterschiedliche Werte haben.

[11:30] Der kleine Monitor hat vielleicht Helligkeit 1 und der andere hat vielleicht Helligkeit 3.

[11:35] Das heißt, die haben alle eine Variable vom Typ Int mit dem Namen Helligkeit.

[11:39] Aber der Wert ist ein unterschiedlicher, denn jedes Objekt hat einen völlig individuellen Wert,

[11:45] der sich theoretisch auch ändern kann.

[11:46] Deswegen sagt man auch gerne zu einem Objekt, das ist eigentlich nichts weiter als ein Zustand.

[11:51] Das ist nämlich eine Sammlung von Variablen, in diesem Fall unserer Instanzvariablen,

[11:55] die einen gewissen Wert haben.

[11:57] Das bedeutet, zu diesem Zeitpunkt hat dieses Objekt einen bestimmten Zustand,

[12:01] nämlich den Wert dieser Variablen.

[12:03] Dieser Zustand, der kann sich auch ändern.

[12:05] Und das ist ein häufiges Problem in der Programmierung.

[12:07] Wenn man nämlich den Zustand ändert, ohne genau zu wissen, warum man das tut oder wie und wo das passiert,

[12:13] dann hat man lustige Fehler in seinem Programm, die sehr schwer zu finden sind.

[12:16] Deswegen geht man heute bei der funktionalen Programmierung zum Beispiel dazu über,

[12:19] diesen Zustand eigentlich wegzulassen.

[12:21] Sondern man will eigentlich gar nicht diese Seiteneffekte haben,

[12:24] dadurch, dass ich zum Beispiel, wenn ich eine Methode aufrufe und eine Instanzvariable ihren Wert geändert hat,

[12:29] dass ich dann auf einmal ein ganz anderes Ergebnis zurückbekomme als vorher.

[12:32] Das ist sehr schwer zu verstehen als Mensch, gerade wenn man komplexe Objekte hat,

[12:36] die ganz, ganz viele Attribute haben und wo es große Abhängigkeiten zwischen den Attributen gibt.

[12:40] Da wird es dann irgendwann ein bisschen schwierig nachzuvollziehen,

[12:42] warum kommt denn jetzt beim Aufruf dieser Methode genau der eine Wert hier zurück.

[12:46] Da muss man dann vielleicht schon mal ein paar verschiedene Variablen sich angucken und schauen,

[12:50] in welcher Kombination kommt es denn jetzt überhaupt dazu, dass ich diesen Wert zurückbekomme.

[12:53] Also, könnte etwas schwierig werden, aber wenn wir mal so auf Azubi-Ebene bleiben und mit der Programmierung anfangen,

[13:00] dann werden wir versuchen, möglichst viel in diese Instanzvariablen reinzupacken,

[13:04] weil das eigentlich die Objektorientierung ausmacht.

[13:06] Das ist das Tolle an der Objektorientierung eigentlich,

[13:08] denn ich kann in diesen Instanzvariablen eben meinen Zustand speichern

[13:11] und die Methoden, die in diesem Objekt oder in der Klasse definiert sind,

[13:15] die können mit diesem Zustand arbeiten.

[13:17] Und das war, als das eingeführt wurde, so ein bisschen auch die Innovation bei der Objektorientierung.

[13:21] Vorher ging das nämlich nicht.

[13:22] Da hatte ich irgendwo meine Datenstrukturen und irgendwo anders meine Algorithmen,

[13:26] die mit diesen Datenstrukturen gearbeitet haben, aber ich hatte sie nicht gemeinsam in einem Ding.

[13:31] Und das habe ich in der Objektorientierung.

[13:32] Da kann ich nämlich meine Klasse nehmen, die ich einmal programmiert habe,

[13:35] und da habe ich sowohl meine Daten drin als auch die Funktionen, die mit diesen Daten arbeiten.

[13:41] Ich habe das also beides als Einheit.

[13:43] Das ist auch eine schöne Erklärung für den Begriff Kapselung, der auch gerne in der Prüfung gefragt wird.

[13:48] Die Kapselung bedeutet halt, dass ich meine Daten und die zugehörigen Methoden

[13:53] gemeinsam in einer Kapsel, nämlich in der Klasse, definieren kann

[13:57] und die dadurch zum Beispiel einfach wiederverwenden kann.

[13:59] Ich kann einfach die Klasse irgendwo hinschieben und dann kann ich die halt komplett benutzen.

[14:03] Vorher musste ich halt meine Daten und meine Funktionen irgendwie separat voneinander übernehmen.

[14:08] So, dann kommen wir nochmal zurück zur Frage, also eine Instanzvariable.

[14:11] Wie definiert man die jetzt?

[14:13] Ich schreibe also irgendwo in meiner Klasse auf oberster Ebene, also im Block der Klasse wirklich,

[14:18] eine ganz normale Variablen-Deklaration hin, zum Beispiel int a.

[14:22] Und damit hat jetzt diese Klasse und damit jedes Objekt dieser Klasse eine Variable vom Typ int mit dem Namen a.

[14:28] Das war's.

[14:29] Jetzt ist aber eine ganz wichtige Frage, wo auch ein großer Unterschied ist zu den lokalen Variablen.

[14:34] Wie werden diese Instanzvariablen initialisiert?

[14:37] Du kennst das bestimmt aus einer Methode, wenn du da eine lokale Variable deklarierst,

[14:42] aber nicht initialisierst, dann wird normalerweise die Promiersprache sagen,

[14:45] hey, Moment mal, da ist irgendwie was falsch.

[14:47] Da wird eine Variable zwar deklariert, aber die bekommt nie einen Wert.

[14:51] Und wenn du dann später versuchst, damit zu arbeiten, dann wird es ein Problem geben.

[14:54] Und das haben wir bei Instanzvariablen genauso.

[14:57] Aber du musst sie nicht explizit initialisieren.

[15:01] Das ist jetzt der große Unterschied.

[15:02] Denn wenn man die Instanzvariable nicht initialisiert, bekommt sie einfach einen Standardwert.

[15:06] Und dieser Standardwert, das ist wichtig zu wissen, welcher das ist,

[15:10] kommt so ein bisschen auch auf die Promiersprache an,

[15:12] aber eigentlich in allen, die ich kenne, ehrlich gesagt,

[15:15] haben die verschiedenen Datentypen die Standardwerte,

[15:18] wenn sie eine Zahl sind, Null,

[15:20] wenn sie ein Boolshar-Wert sind, False,

[15:23] und wenn sie irgendein Referenztyp sind,

[15:26] dann haben sie den ganz besonderen Wert Null.

[15:29] Und Null, das ist ein ganz tolles Konzept.

[15:32] Darüber habe ich vor einigen Wochen schon mal so einen tollen Link der Woche gepostet.

[15:36] Und zwar, warum Null eigentlich der größte Fehler in der Informatik war,

[15:40] der jemals gemacht wurde, quasi.

[15:42] Weil er uns nämlich bis heute eigentlich immer in der Programmierung verfolgt.

[15:45] Vielleicht hast du selber schon mal irgendwo einen Null-Pointer gehabt.

[15:48] Das bedeutet, wir haben eine Variable, die hat keinen Wert.

[15:51] Das bedeutet letztlich dieses Null.

[15:53] Und an dieser Variable wird dann irgendwas aufgerufen.

[15:55] Zum Beispiel bei dem Auto von eben.

[15:58] Und ich mache jetzt Auto.getLänge.

[16:00] Aber das Auto ist Null, das ist also nicht initialisiert.

[16:02] Es hat keinen Wert.

[16:04] Dann gibt es diesen Null-Pointer, weil versucht wird,

[16:07] an einem Objekt, das es nicht gibt, etwas aufzurufen.

[16:10] Und das ist in der Programmierung ganz, ganz schwierig manchmal,

[16:13] herauszufinden, wo dieser Null-Pointer herkommt.

[16:16] Wenn wir irgendwo mit einem Auto arbeiten,

[16:18] dann ist ganz schwer herauszufinden, warum dieses Auto jetzt Null ist.

[16:22] Denn es ist nicht unbedingt immer ersichtlich,

[16:24] in der Zeile da drüber wird gerade das Auto instanziert und initialisiert,

[16:28] sondern in komplexen Systemen kann es sein,

[16:30] dass diese Deklaration der Variablen und die Initialisierung

[16:33] an ganz verschiedenen Stellen im Code stattfinden.

[16:36] Und auch noch an ganz verschiedenen Stellen zu der,

[16:38] wo wir eigentlich gerade den Fehler haben.

[16:40] Das erkennt man immer schön daran,

[16:42] wenn man auch diesen riesen Stack Trace manchmal sieht,

[16:44] wenn man zum Beispiel in Java oder C Sharp einen Fehler bekommt,

[16:47] dass man das nachvollziehen muss.

[16:48] Wie kommt es überhaupt dazu, dass Sie jetzt nach 739 aufrufen,

[16:52] genau dieser Wert Null ist?

[16:53] Es ist ganz, ganz schwer, das herauszufinden.

[16:55] Und von daher, wenn es irgendwie geht, tu alles Mögliche,

[16:59] damit du nicht mit solchen Nullwerten rumhantieren musst.

[17:02] Dazu kann ich nochmal den Artikel empfehlen.

[17:04] Ich werde den auch nochmal in die Shownotes packen.

[17:06] Aber merkt ihr erstmal, Null ist böse.

[17:09] Wir wollen kein Null. Wir wollen nicht mit Null arbeiten.

[17:12] Aber jetzt nochmal vielleicht zurück zur Frage,

[17:14] was ist denn jetzt überhaupt Null?

[17:15] Ich hatte es gerade schon kurz gesagt.

[17:16] Also Null ist im Prinzip einfach der Standardwert für Referenztypen.

[17:20] Das heißt für alle Datentypen, die eben nicht die primitiven Datentypen sind,

[17:23] wie zum Beispiel Int und Char und so weiter.

[17:25] Und der erste nicht primitive Datentyp,

[17:28] den du sehr wahrscheinlich schon 100 Mal benutzt hast, ist String.

[17:31] String ist zum Beispiel in Java ein Referenztyp.

[17:34] Und wenn ich einen leeren String… Entschuldigung, leerer String ist falsch.

[17:37] Ein leerer String ist ein gültiger String.

[17:39] Aber wenn ich einen String nicht initialisiere, dann hat er den Wert Null.

[17:43] Also Standardwert für Referenztypen.

[17:46] Und bedeutet eben so viel wie nicht gesetzt.

[17:49] Deswegen ist auch ganz, ganz wichtig,

[17:51] dass man als Informatiker das Ding nicht Null nennt.

[17:53] Es wird ja N-U-L-L geschrieben,

[17:56] aber wir sprechen das bewusst Englisch als Null aus.

[17:59] Denn wir müssen im Deutschen unterscheiden zwischen dem Wert Null,

[18:02] also der Zahl Null, und diesem nicht initialisierten Zustand Null.

[18:07] Das ist etwas völlig anderes.

[18:09] Ich kann zum Beispiel, wenn ich in Java die Klasse Integer benutze mit großem I,

[18:13] das ist ein Referenztyp.

[18:15] Und wenn ich die nicht initialisiere, hat die den Wert Null.

[18:18] Wenn ich ihr aber den Wert Null gebe,

[18:21] dann hat sie sehr wohl einen Wert.

[18:23] Denn Null kann ja ein ganz normaler, gültiger Wert sein.

[18:26] Zum Beispiel Null Euro steuern.

[18:28] Das wäre immer eine tolle Sache.

[18:30] Das ist ein gültiger Wert.

[18:31] Wenn ich aber Null in dieser Variablen habe,

[18:33] dann ist das eben kein gültiger Wert.

[18:35] Das bedeutet nämlich, dass der Wert nicht gesetzt ist.

[18:37] Also das muss ich unterscheiden können.

[18:38] Deswegen sagen wir bewusst Null und nicht Null.

[18:41] Die Englisch Sprechenden unter uns haben es etwas einfacher.

[18:44] Die sagen auf Englisch einfach Zero.

[18:46] Und Zero und Null ist kein Problem.

[18:48] Aber im Deutschen haben wir halt eben die Null.

[18:50] Deswegen müssen wir das ein bisschen anders aussprechen.

[18:52] Vielen Dank für's Zuschauen.

[18:53] So, jetzt haben wir also so Instanzvariablen da definiert. Wir wissen jetzt auch, mit welchen

[18:56] Standardwerten die initialisiert werden, sogar automatisch, ohne dass ich was tun

[19:00] muss. Da war ich ja gerade stehen geblieben. Wenn ich jetzt also einfach in meiner Klasse

[19:02] sage int a und ich mache nichts weiter, dann hat die einfach automatisch den

[19:06] Wert 0. Die wird also mit 0 initialisiert, wie jeder andere Zahlenwert auch.

[19:10] Strings würden halt eben zum Beispiel mit null initialisiert werden. Also, das ist

[19:14] schon mal ein großer Unterschied zur lokalen Variablen. Ich muss sie nicht

[19:17] initialisieren. Sie werden quasi implizit mit Standardwerten initialisiert.

[19:21] Jetzt habe ich diese Variablen also definiert. Jetzt ist ja die erste Frage,

[19:24] wie komme ich denn da dran? Wie kann ich denn mit denen arbeiten? Und das kann ich

[19:27] jetzt über den besonderen Operator. In C-Sharp, in Java wäre das der Punkt. Der

[19:31] Punkt, den schreibe ich einfach hinter den Namen der Variable, in der

[19:35] mein Objekt ist und dann kann ich direkt auf die Variable zugreifen, so wie

[19:40] ich es sonst auch machen würde. Also, Beispiel, ich würde sowas machen wie

[19:43] auto a gleich new auto. Dann könnte ich mit a Punkt zum Beispiel, was hatten wir

[19:49] gerade, Farbe, könnte dann eben auf die Farbe von dem Auto zugreifen. Also einfach

[19:54] mit dem Punkt-Operator. Jetzt gibt es bei diesen Variablen, die ich in meiner

[19:58] Klasse definieren kann, noch eine kleine Besonderheit. Es gibt nämlich noch ein

[20:01] kleines Schlüsselwörtchen. Das heißt Static. Ich kann also auch Static-

[20:05] Variablen definieren oder statische Variablen oder die heißen dann auch

[20:10] Klassenvariablen. Und diese Klassenvariablen sind eben nicht an ein

[20:14] Objekt geknüpft, sondern an die Klasse. Das bedeutet, dass sie genau einen Wert

[20:19] für die eine Klasse haben und nicht für jedes Objekt einen unterschiedlichen

[20:23] Wert annehmen können. Das hatte ich, glaube ich, beim letzten Mal schon mal so kurz

[20:26] angerissen. Als Beispiel beim Auto könnte ich mir sowas vorstellen, so ein bisschen

[20:31] konstruiert. Angenommen, es gäbe in Deutschland eine maximale Höchstgeschwindigkeit

[20:35] auf Autobahnen, sagen wir mal 130 kmh, dann könnte ich an der Klasse Auto eine

[20:40] Variable vom Typ Int hinterlegen, die Static ist und die hat dann einfach den

[20:44] Wert 130. Ich könnte also sowas machen, wie zum Beispiel Static Int

[20:50] Höchstgeschwindigkeit gleich 130. Das Höchstgeschwindigkeit übrigens mit OE

[20:54] natürlich und niemals mit Ö bitte, aber das nur nebenbei. Und die könnte ich

[20:58] Static machen. Das bedeutet, ich kann dann einfach über das Auto auf diese 130

[21:01] zugreifen, aber es kann nicht jedes Auto seine eigene Höchstgeschwindigkeit

[21:05] festlegen. Das wäre ein bisschen blöd. Also wenn es jetzt die bundeseinheitlich

[21:09] vorgeschrieben Höchstgeschwindigkeit ist. Ich meine nicht die

[21:11] Höchstgeschwindigkeit des Autos selber, also zum Beispiel kleiner Ford kann

[21:15] maximal 150, aber der große BMW kann 200. Ja, das meine ich nicht, sondern quasi

[21:20] eine Höchstgeschwindigkeit auf Autobahnen. Das könnte ich als Static

[21:23] Variable hinterlegen, dann ist sie nämlich für alle Autos fest und

[21:27] vorgegeben. Fest nicht, aber vorgegeben und zwar einheitlich. Das heißt, wenn ich

[21:31] diese Variablen ändere, dann gilt das auch automatisch für alle Autos und nicht

[21:34] eben nur für dieses eine, was sie sich vielleicht selber gemerkt hat. Und diese

[21:39] Static Variablen und die Instanz Variablen oder anders genannt die

[21:43] Klassen und die Objekt Variablen, wenn man die gemeinsam irgendwie benennen

[21:48] möchte, dann gibt es dafür noch einen schönen Begriff und das nennt man dann

[21:51] gerne Feld oder auf Englisch Field. Wenn ich von den Variablen einer Klasse

[21:56] spreche, dann ist manchmal interessant, ob es Static Variablen oder Instanz

[22:00] Variablen sind oder eben beides. Und wenn ich beide meine, dann kann ich dafür

[22:05] auch den Begriff Feld verwenden. Das fasst also quasi meine Klassen und meine

[22:09] Instanz Variablen zusammen. Aber noch mal kurz erklärt also, die Static Variablen

[22:15] gelten für die Klasse, die Instanz Variablen jeweils nur für ein Objekt.

[22:19] Ich kann also unterschiedliche Werte annehmen, je nach Objekt. Der Zugriff auf

[22:24] diese Static Variablen erfolgt logischerweise dann auch über die Klasse

[22:28] und eben nicht über das Objekt. Ich kann also sowas machen wie Auto Punkt

[22:31] Höchstgeschwindigkeit. Dann habe ich wirklich diese eine Variable, die für

[22:35] alle Autos gleich ist. Ich kann auch über Objekte auf die Static Variablen

[22:40] zugreifen, zumindest in Java. In anderen Programmiersprachen geht es vielleicht

[22:43] nicht. Ich könnte also sowas machen wie Auto A gleich New Auto und dann A Punkt

[22:47] Höchstgeschwindigkeit und darüber auf die Static Variable zugreifen. Aber

[22:51] vernünftige Programmierer werden das nicht tun und solche netten IDEs wie

[22:55] Eclipse zum Beispiel würden mir vorschlagen, was ich da gerade mache ist

[22:58] Grütze, mach das mal bitte anders und schreib mal Auto Punkt Höchstgeschwindigkeit.

[23:01] Also die unterschlängeln das gleich gelb und sagen mir, mach das mal

[23:04] vernünftig. Und das würde ich auch immer empfehlen, denn diese Variable hängt eben

[23:08] an der Klasse und nicht am Objekt. Und wenn ich als Entwickler darauf gucke, A

[23:12] Punkt Höchstgeschwindigkeit, dann sieht das aus wie eine Instanzvariable. Ist es

[23:16] aber nicht, das ist verwirrend, das wollen wir nicht in unserem Code haben. Also

[23:19] sein lassen bitte. So, dann kommen wir jetzt zum zweiten Teil der Objekte und

[23:25] Klassen, nämlich den Methoden. Wir haben schon kennengelernt, die Attribute, das

[23:29] waren jetzt unsere Variablen und jetzt kommen wir zu den Funktionen, die solche

[23:32] Objekte noch mitbringen. Und die heißen in der Objekteorientierung einfach

[23:35] Methode. Man muss sich ja irgendeinen Namen dafür ausdenken.

[23:37] Man könnte sie jetzt einfach Funktion nennen, ja wäre vielleicht einfacher

[23:40] gewesen, aber in der Objekteorientierung heißen jetzt einfach Methoden. Also die

[23:44] Funktionen, die solche Objekte bereitstellen und die in den Klassen

[23:47] definiert werden, die heißen Methoden. Wie ruft man solche Methoden auf, wenn ich

[23:51] die programmiert habe? Wie man die programmiert, haben wir im letzten Mal schon

[23:53] kennengelernt. Ja, die Methodensignaturen, den ganzen Schnickschnack, da wollen wir

[23:56] nicht alles noch mal im Detail durchkauen, nur ganz kurz und nochmal wieder

[24:00] auf den Stand zu kommen. Wenn ich eine Methode aufrufen möchte, dann mache ich

[24:03] das genau wie bei der Instanz Variable über den Punkt-Operator. Also ich mache

[24:07] wieder beim Auto-Beispiel a.fahre oder sowas. Ja, also wieder über den Punkt,

[24:13] genau wie bei den Variablen. Und mal ganz kurz als Wiederholung, die

[24:16] Methodensignature, das ist der Name der Methode und die Anzahl und die

[24:22] Datentypen der Parameter, die diese Methode reinbekommt. Das ist die

[24:27] Signatur. Aus diesen beiden Bestandteilen besteht sie. Der Rückgabewert, der ist

[24:31] zwar interessant für uns Entwickler, ist aber nicht Bestandteil

[24:36] der Methodensignatur. So, wenn ich so eine Methode aufrufe, dann kann man das genauso

[24:42] nennen, wie ich es gerade gesagt habe. Ich rufe eine Methode auf. Es gibt aber noch

[24:45] andere Programmiersprachen, zum Beispiel etwas dynamischere wie Ruby. Die nennen

[24:49] das gerne ein bisschen anders, nämlich ich schicke eine Nachricht an ein Objekt.

[24:53] Die ursprüngliche Idee der Objektorientierung damals in den 70er Jahren aus Smalltalk,

[24:59] in der ersten eigentlich objektorientierten Programmiersprache, da war es damals schon so,

[25:03] dass die Objekte eigentlich relativ eigenständige Dinge eben waren. Es sollte

[25:08] halt eben ein Abbild der Realität sein. Also zwei unterschiedliche Dinge, die zum

[25:11] Beispiel miteinander kommunizieren. Und da hat man sich halt überlegt, wie kann man

[25:14] das nennen. Und in Analogie zu dem, was tatsächlich auch vielleicht, wenn

[25:20] Maschinen miteinander kommunizieren würden, was sie tun würden, die schicken

[25:23] sich halt irgendwelche Nachrichten hin und her. Und das Ganze kann man jetzt

[25:25] auch runterbrechen auf die Objektorientierung. Wenn zwei Objekte

[25:28] miteinander sprechen, da könnte man es einfach so nennen, dass ein Objekt

[25:31] schickt eine Nachricht an ein anderes Objekt. Ist aber letztlich nichts anderes

[25:35] damit gemeint, als eine Methode wird aufgerufen an dem anderen Objekt. Also

[25:39] wenn ich jetzt zum Beispiel sage, bei meinem Auto, was hatte ich jetzt gerade?

[25:42] Fahre. Ja, dann kann ich sagen, ich rufe die Fahre-Methode auf. Ich kann aber auch

[25:46] sagen, ich schicke dem Auto die Nachricht Fahre. Ja, das ist identisch. Das meint

[25:50] das Gleiche, ist nur eine etwas andere Art und Weise, sich auszudrücken. Und

[25:54] gerade zum Beispiel im Ruby-Umfeld wird diese Ausdrucksweise sehr häufig benutzt.

[25:58] Also nicht wundern, wenn man mal so ein paar Texte über Objektorientierung liest und

[26:01] da sprechen die Leute ständig von irgendwelchen Nachrichten. Das ist einfach

[26:03] nur gemeint, dass da Methoden aufgerufen werden. Etwas anders ist es dann wieder,

[26:08] genau wie bei den statischen Variablen, bei den statischen Methoden. Die werden

[26:13] nämlich auch wieder anders aufgerufen, nämlich nicht über das Objekt, sondern

[26:15] kannst du dir schon vorstellen, über die Klasse. Das heißt, ich würde da wieder

[26:19] sowas machen wie Auto. Und jetzt müsste ich mir schon ein bisschen überlegen, was

[26:23] wäre denn eine mögliche statische Methode bei einem Auto? Also eine

[26:26] Funktion, die für alle Autos identisch ist. Ja, da fällt mir jetzt einfach mal

[26:31] spontan nichts ein. Ist auch nicht so wichtig. Aber wenn es sowas gäbe, würde

[26:34] ich das eben als statische Methode abbilden und nicht als Instanzmethode.

[26:38] Dann könnte diese statische Methode auch nicht auf die Instanzvariablen

[26:42] zugreifen. Das ist ganz wichtig. Alles, was im statischen Kontext definiert ist,

[26:46] kann nicht auf das Dynamische zugreifen, also auf die Instanzmethoden und

[26:50] Instanzvariablen. Umgekehrt geht das sehr wohl. Ich kann aus einer Instanzmethode

[26:54] eine statische Methode aufrufen. Ich kann auch ein statisches Feld abfragen. Das

[26:58] geht auch. Aber umgekehrt, das geht nicht. Also immer, wenn ich im Static-Kontext

[27:03] bin, kann ich nicht auf Instanzmethoden und Instanzvariablen zugreifen. Ist auch

[27:07] logisch, denn wir hatten ja gerade gesagt, die Klassenmethoden und die Klassenvariablen,

[27:13] die gelten für die gesamte Klasse und nicht für ein konkretes Objekt. Und wenn

[27:18] ich jetzt aber aus dieser Klassenmethode auf die Instanzvariable eines Objekts

[27:22] zugreifen könnte, dann wäre die Methode ja nicht mehr allgemeingültig. Das darf

[27:26] also nicht funktionieren. So, dann kommen wir noch zu einem

[27:30] weiteren Fachbegriff, den man durchaus kennen könnte. Und zwar haben wir jetzt

[27:33] kennengelernt, es gibt Attribute und es gibt Methoden in so einer Klasse. Wenn ich

[27:37] jetzt beides gemeinsam benennen möchte, weil ich darüber sprechen möchte oder

[27:41] darüber einen Artikel schreiben will, dann brauche ich dafür vielleicht auch

[27:44] so einen Oberbegriff. Und da wird gerne der Begriff Member benutzt, also das

[27:48] englische Wort für Mitglied. Ich würde das nicht als Mitglied auf Deutsch

[27:52] nennen, aber ich sage auf Deutsch eigentlich auch immer Member dazu. Also

[27:57] wenn ich die Member einer Klasse, wenn ich davon spreche, dann ist das der

[28:00] Oberbegriff für alle Felder und Methoden. Das heißt, es werden also auch alle

[28:05] statischen Methoden und Variablen darunter verstanden. Also das heißt, im

[28:10] Prinzip Member sind die statischen Methoden und Variablen und die

[28:13] Instanzmethoden und Variablen. Wenn ich dafür irgendwie einen Oberbegriff

[28:17] brauche, weil ich darüber gerade sprechen will, dann kann ich dafür den Begriff

[28:20] Member verwenden. Dann haben wir eigentlich alle wichtigsten Begriffe der

[28:25] Objektorientierung, Klasse und Objektmethoden und Attribute durch, aber zwei

[28:29] Kleinigkeiten noch einmal zum Abschluss, und zwar noch etwas Konkretes zu Java.

[28:33] Irgendwie brauchen wir auch noch eine etwas übergeordnete Struktur, wenn wir

[28:37] verschiedene Klassen anlegen, dass wir die auch irgendwie miteinander in

[28:40] Verbindung setzen können, dass wir die noch ein bisschen gruppieren können und

[28:43] so weiter. Und das wäre jetzt in Java das nächsthöhere nach der Klasse quasi,

[28:47] so eine Art Ort, wo ich mehrere Klassen zusammenfassen kann. Das wäre dann das

[28:52] Package. Ein Package, das dient einfach der Gruppierung zusammengehöriger

[28:56] Klassen. Wenn man es mal überträgt aufs Dateisystem zum Beispiel, wäre das

[29:01] einfach ein Ordner, ein Verzeichnis in einem Dateisystem. Und da packe ich dann

[29:04] zum Beispiel all die Klassen zusammen rein, die irgendwie zusammengehören.

[29:07] Ich hätte also zum Beispiel meine Autowaschanlage und meine Klasse Auto

[29:10] und vielleicht noch meine Klasse, was weiß ich, Autowaschanlagensteuerung, was wir

[29:16] mal ganz komplex machen. Wir sind ja in Java, da kann man ruhig ganz lange Klassennamen

[29:19] bewenden. Und die packen wir dann zusammen in das Package, meine tolle

[29:23] Autowaschanlage. Das wäre ein doofer Packagename und vor allem, weil man in Java nur

[29:27] Kleinbuchstaben benutzen darf und auch keine Bindestriche, wird das dann etwas

[29:30] schwer zu lesen. Aber das könnten wir so tun. Also ein Package ist nichts weiter

[29:34] als ein Ordner, in dem mehrere Klassen, die optimalerweise irgendeine Beziehung

[29:38] zueinander haben, zusammengefasst werden, damit man sie leichter verwalten kann.

[29:41] Und jetzt haben wir aber ein kleines Problem. Wenn wir nämlich jetzt Klassen

[29:45] aus einem anderen Package brauchen, weil zum Beispiel die Autowaschanlage auch

[29:49] gerne noch mal ihre Abrechnungen an das Kassensystem melden möchte und diese

[29:53] Kassenklassen sind in einem anderen Package, dann muss

[29:59] dieses Package erst mal importiert werden bzw. die Klassen dieses Packages

[30:04] müssen importiert werden, damit die Autowaschanlage das überhaupt benutzen

[30:07] kann. Denn in Java ist es so, dass die Klassen eines Packages nicht automatisch

[30:11] alle anderen Klassen, die es irgendwo da draußen in der Welt noch gibt, zur

[30:13] Verfügung haben, sondern ich muss explizit sagen, welche Klassen ich denn

[30:16] so benutzen möchte. Und das mache ich mit dem Import-Schlüsselwort. Deswegen sieht

[30:21] man auch, wenn man in Java ganz oben mal in die Klasse schaut, als allererstes

[30:24] nach der Package-Definition, in der ich sage, in welchem Package ich selber bin,

[30:28] also meiner Klasse, stehen als allererstes die Import-Statements, wo dann

[30:32] steht, welche anderen Klassen diese lokale Klasse benutzen möchte. Also

[30:37] müsste zum Beispiel in der Klasse Auto, wenn die direkt an das Kassensystem was

[30:41] melden sollte, was nicht so sinnvoll wäre, aber angenommen, die müsste das tun, dann

[30:45] würde da oben stehen, Package, meine tolle Autowaschanlage, Import, mein tolles

[30:49] Kassensystem, Punkt Kasse. Und dann ist die Klasse Kasse, mein Gott, ich habe mir

[30:55] echt bescheuerte Beispiele ausgedacht, aber die wäre dann in der Klasse Auto

[30:58] verfügbar. Und dann könnte das Auto zum Beispiel so was machen wie Kasse K gleich

[31:04] New Kasse, K, Punkt, rechne ab, 5,79 Euro oder so was. Ja, das könnte man dann tun.

[31:09] Das ist quasi dann der Oberbegriff, um in Java mehrere Klassen zusammenzufassen,

[31:14] ein Package. Und mit dem Import importiere ich mir dann die Klassen aus fremden

[31:18] Packages, um die zu benutzen. So, damit haben wir für heute erstmal

[31:23] alles fertig. Bevor mir wieder gesagt wird, ich vernachlässige die .NET-Leute,

[31:27] ein Konzept eines Packages gibt es in .NET nicht, da sind das quasi die

[31:32] Namespaces. Unter C-Sharp zum Beispiel oder Visual Basic kann ich Namespaces

[31:36] definieren, die letztlich nichts anderes sind als Packages, nur dass es in Java

[31:40] eine, sage ich mal, harte Verdrahtung gibt mit den Ordnern im Dateisystem. Wenn ich

[31:44] also meine Klasse in ein Package lege, muss die auch im Dateisystem auf der

[31:48] Festplatte in der entsprechenden Ordnerstruktur, die zur Package-Struktur

[31:51] passt, liegen. In C-Sharp ist das nicht so, da kann ich einfach Namespaces definieren,

[31:55] die müssen aber keine Beziehungen zu den entsprechenden Ordnern auf der

[31:58] Festplatte haben. Es wäre schön, muss aber nicht. So, damit wären wir durch. Ich habe

[32:03] es mal wieder ziemlich genau auf die 30 Minuten geschafft. Das ist super. In den

[32:06] letzten Lehrzielkontrollen waren immer ein bisschen länger, aber heute habe ich es

[32:09] mal wieder genau gepackt. Das ist schon mal sehr gut. Das war übrigens heute die

[32:13] letzte Episode für das Jahr 2015. Ich mache jetzt erstmal so eine kleine

[32:17] Weihnachtspause. Ich hoffe, das ist okay und ich bin erst dann im Januar 2016

[32:21] wieder mit der nächsten Episode am Start. Aber dann geht es natürlich weiter. Wir

[32:25] haben noch ganz ganz viel zu lernen bei der Objektorientierung und von daher

[32:28] keine Angst, ich werde auf jeden Fall weitermachen. Wenn du dich in der Zeit

[32:31] schon mal einlesen willst oder noch mal tiefer einsteigen willst in das Thema

[32:34] Objektorientierung oder Java insbesondere, dann kann ich wie immer zwei

[32:38] super Bücher empfehlen, nämlich einmal die Einführung in Java aus dem

[32:41] Rheinwerk-Verlag und natürlich Java ist auch eine Insel, auch aus dem

[32:45] Rheinwerk-Verlag. Wie immer meine Standardliteratur rund um Java. Ich habe

[32:49] in den Shownotes auch noch mal ein paar Open-Book-Kapitel aus der Java-Insel

[32:53] verlinkt und auch noch mal ein paar andere Artikel, die noch mal an der

[32:56] anderen Stelle tiefer reingehen. Auch zum Beispiel das Java-Tutorial ist

[33:00] wieder wie immer empfehlenswert. Und wenn du dir die Sachen anschauen willst, dann

[33:04] kannst du es am besten über die Shownotes machen. Die Adresse ist wie

[33:07] immer www.anwendungsentwicklerpodcast.de

[33:10] 4343, also für die 43. Episode heute. Ja, es freut mich, dass du mir so lange

[33:18] treu warst und dass ich dieses Jahr sehr erfolgreich beenden kann mit ganz vielen

[33:23] Downloads und ganz viel Feedback und ganz viel positiven Rückmeldungen von

[33:26] meinen Hörern und den Bloglesern. Und von daher würde ich mich auch wie immer

[33:30] über dein Feedback freuen, wenn du mir mal mitteilen willst, was du vielleicht

[33:34] schon an Inhalten aus meinem Podcast, von der Website und so weiter nutzen

[33:37] konntest und dass ich dir vielleicht irgendwie helfen konnte. Da würde ich

[33:40] mich wirklich sehr, sehr darüber freuen. Das ist das, warum ich das hier mache.

[33:43] Ich möchte natürlich auch gerne Feedback für das bekommen, was ich hier

[33:46] tue. Von daher, wenn du mir irgendwas schreiben möchtest, dann tu das gerne. Du

[33:50] kannst mir eine Mail schreiben unter mail at www.anwendungsentwicklerpodcast.de

[33:53] Du kannst das Kontaktformular benutzen. Du kannst mir einen Kommentar unter den

[33:57] Artikel hier schreiben oder du findest mich unter www.anwendungsentwicklerpodcast.de

[34:01] und dann iTunes oder Stitcher oder Facebook oder Twitter oder Xing. Da

[34:07] kannst du mich überall gerne kontaktieren und ich versuche immer

[34:09] möglichst schnell auf alle Anfragen und auch vor allem Fragen rund um die

[34:12] Ausbildung zu antworten. Wenn du noch ein paar mehr nette, spannende, tolle Inhalte

[34:19] von mir haben willst, dann guck doch mal ins Blog. Da habe ich nämlich letzte

[34:23] Woche einen sehr umfangreichen Artikel zum Thema Vorbereitung auf das

[34:26] Fachgespräch geschrieben. Wenn du also gerade kurz vor der mündlichen Prüfung

[34:29] stehst, dann schau dir das doch mal an. Da sind noch ein paar Tipps, wie man sich ganz

[34:32] gut darauf vorbereiten kann. Vor allem auch auf potenzielle Themen, die man dann

[34:36] vielleicht gefragt wird. Das ist ja meist die erste Frage. Was kommt denn da

[34:39] dran? Was wird denn gefragt? Und da habe ich mal so ein paar Tipps, wie man da

[34:41] vielleicht darauf kommen kann. Und ich habe auch noch einen schönen Link der Woche

[34:44] gehabt, nämlich Innovationen in Legacy-Systemen. Ich bin ja auch häufig in

[34:48] Legacy-Systemen unterwegs und entwickle da neue Sachen rein und ich habe dann

[34:52] einen schönen Link der Woche, wo es auch darum geht, wie man in diese Legacy-Systeme

[34:57] noch mal ein bisschen innovative, coole Sachen einbauen kann. Also kann ich dir

[35:00] empfehlen. Schau doch mal rein. Und zuletzt wie immer die Empfehlung, wenn

[35:04] du magst, trage dich in meinen Newsletter ein unter anmeldungsentwicklerpodcast.de

[35:08] slash Newsletter. Da bekommst du immer sofort eine Info, wenn es eine neue

[35:11] Podcast-Episode gibt. Und natürlich auch meine Links der Woche. Die gibt es immer

[35:14] schon vorab. Und ja, alle möglichen anderen Dinge, wenn ich irgendwie in

[35:17] Kommunikation mit meinen Hörern treten will, mache ich das immer als erstes

[35:20] über den Newsletter. Also wenn du Bock hast, trag dich ein. Kannst dich auch jederzeit

[35:23] wieder austragen. Es gibt da keine Verpflichtung. Kostet auch nichts

[35:27] übrigens. Ja, alles weiterhin kostenlos, was ich hier anbiete. Von daher, wenn du

[35:30] möchtest, trag dir einfach gerne ein. Das nächste Mal hören wir uns dann

[35:34] Anfang 2016, wenn ich mit der nächsten Objektorientierungs-Lernzielkontrollen-

[35:40] Episode weitermache. Und bis dahin wünsche dir ein paar schöne Weihnachtstage, wenn

[35:45] du es noch Ende 2015 hörst, die Episode hier. Wenn du es mitten im Sommer hörst,

[35:49] dann einfach ignorieren, was ich erzähle. Ansonsten frohe Weihnachtsfeiertage,

[35:54] einen guten Rutsch ins Jahr 2016 und bis zum nächsten Jahr.

[35:58] Vielen Dank fürs Zuhören und bis dahin. Tschüss!