- Zeichensätze und -kodierung – Anwendungsentwickler-Podcast #32
- HTML – Anwendungsentwickler-Podcast #33
- Java (Lernzielkontrolle) – Anwendungsentwickler-Podcast #36
- Allgemeine Fragen zur Programmierung (Lernzielkontrolle) – Anwendungsentwickler-Podcast #37
- Variablen und Operatoren (Lernzielkontrolle) – Anwendungsentwickler-Podcast #38
- Zahlen und Zeichen (Lernzielkontrolle) – Anwendungsentwickler-Podcast #39
- Algorithmen und Methoden (Lernzielkontrolle) – Anwendungsentwickler-Podcast #42
- Objektorientierung Teil 1 (Lernzielkontrolle) – Anwendungsentwickler-Podcast #43
- Objektorientierung Teil 2 (Lernzielkontrolle) – Anwendungsentwickler-Podcast #44
- Datenbankmodellierung (Lernzielkontrolle zum Entity-Relationship-Modell) – Anwendungsentwickler-Podcast #48
- Datenbankmodellierung (Lernzielkontrolle zum relationalen Tabellenmodell) – Anwendungsentwickler-Podcast #49
- Java EE 7 (Lernzielkontrolle) – Anwendungsentwickler-Podcast #54
- Fehlerbehandlung (Lernzielkontrolle zu Exceptions) – Anwendungsentwickler-Podcast #79
- Arrays und Listen (Lernzielkontrolle) – Anwendungsentwickler-Podcast #99
Sichtbarkeitsmodifizierer und Konstruktoren sind die Themen der vierundvierzigsten Episode des Anwendungsentwickler-Podcasts.
TL;DR
An der Klasse Auto zeige ich dir, wie du mit this auf das aktuelle Objekt zugreifst und Konstruktoren miteinander verknüpfst. Konstruktoren sorgen dafür, dass ein neues Objekt gültige Attributwerte erhält, während Sichtbarkeitsmodifizierer den Zugriff auf seine Attribute und Methoden regeln. Als Entwickler:in deiner Klasse bist du dafür verantwortlich, dass sie sich vollständig initialisiert und andere Entwickler:innen direkt mit ihren Objekten arbeiten können.
Podcast: Play in new window | Download (Duration: 34:45 — 15.9MB)
Abonnieren: Apple Podcasts | Spotify | RSS
Kapitelmarken
- [00:00:01] Einstieg in die zweite Lernzielkontrolle zur Objektorientierung
- [00:01:53] this als Referenz auf das aktuelle Objekt
- [00:05:23] Konstruktoren und gültige Objektzustände
- [00:08:08] Konstruktoren definieren und überladen
- [00:10:13] Gemeinsamen Konstruktorcode mit this wiederverwenden
- [00:14:25] Faustregel für verkettete Konstruktoren
- [00:15:05] Kapselung und Geheimnisprinzip
- [00:16:45] Sichtbarkeit mit public, private und protected regeln
- [00:20:24] Package-private in Java
- [00:22:06] Empfehlungen zur Sichtbarkeit und zu Tests
- [00:23:45] Die Java-Sichtbarkeiten im Überblick
- [00:24:47] Instanzvariablen vollständig initialisieren
- [00:27:23] Anfangswerte im Code setzen
- [00:29:37] Namenskonflikte mit this auflösen
- [00:32:12] Ausblick, Literatur und weiterführende Links
Inhalt
Konstruktoren
- Was macht das Schlüsselwort
this?- Referenz auf das aktuelle Objekt.
- Was ist die Aufgabe eines Konstruktors?
- Ein Objekt zu erzeugen und es in einen gültigen Zustand zu versetzen.
- Wie definiert man einen Konstruktor?
- In Java: Methode ohne Rückgabewert und dem gleichen Namen wie die Klasse.
- Was ist ein Default-Konstruktor?
- Der parameterlose Konstruktor einer Klasse, der ggfs. durch Java selbst erzeugt wird.
Sichtbarkeitsmodifizierer
- Wie steuert man die Sichtbarkeit von Attributen und Methoden von Klassen?
- Mit den Sichtbarkeitsmodifizierern
private,protected,publicund package-private.
- Mit den Sichtbarkeitsmodifizierern
- Was ist die standardmäßige Sichtbarkeit in Java?
- package-private
- Wie kann man Instanzvariablen initialisieren?
- Inline bei ihrer Deklaration, im Konstruktor oder in einer Methode.
- Muss man Instanzvariablen immer über
thisansprechen?- Nein, nur wenn es einen Namenskonflikt gibt.
Literaturempfehlungen
Links
- Permalink zu dieser Podcast-Episode
- RSS-Feed des Podcasts
- Rheinwerk Computing :: Java ist auch eine Insel – 5.2 Privatsphäre und Sichtbarkeit
- Rheinwerk Computing :: Java ist auch eine Insel – 5.5 Objekte anlegen und zerstören
Zusammenfassung
Mit this auf das aktuelle Objekt zugreifen
Wenn du mit Auto a = new Auto(); ein Objekt erzeugst, kannst du über die Referenz a seine zugänglichen Methoden aufrufen. Innerhalb des Objekts steht dir dafür this als Referenz auf das aktuelle Objekt zur Verfügung. Mit this.kilometerstand += 1; erhöhst du beispielsweise den eigenen Kilometerstand.
In einer Methode der Klasse Auto bezieht sich this auf das jeweilige Autoobjekt. Schreibst du es innerhalb einer Methode der Klasse Autowaschanlage, verweist es auf das aktuelle Objekt dieser Klasse.
Für eine Prüfung kannst du dir die Formulierung merken: this ist eine Referenz auf das aktuelle Objekt.
Konstruktoren und gültige Objektzustände
Beim Erzeugen eines Objekts wird ein Konstruktor aufgerufen, der dessen Attribute mit gültigen Werten versieht. Der Zustand eines Objekts ergibt sich aus den aktuellen Werten aller seiner Attribute.
Java gibt Instanzvariablen zunächst Standardwerte. Numerische Attribute erhalten 0, bei einem booleschen Attribut ist der Wert false. Referenzen wie String-Attribute beginnen mit null. Welche Werte fachlich gültig sind, hängt von deiner Klasse ab. Ein leerer String kann beispielsweise verhindern, dass der spätere Zugriff auf dieses Attribut einen Null-Pointer-Fehler auslöst.
Wenn du in Java keinen eigenen Konstruktor definierst, erzeugt die Sprache einen parameterlosen Default-Konstruktor. Sobald deine Klasse eigene Schritte braucht, um einen gültigen Zustand herzustellen, musst du diese selbst programmieren.
So sieht ein Konstruktor aus
In Java und C# trägt ein Konstruktor exakt den Namen seiner Klasse, einschließlich der Groß- und Kleinschreibung. Der Rückgabetyp entfällt vollständig, auch void.
Für die Klasse Auto lautet ein parameterloser Konstruktor beispielsweise:
java
Auto() {
this.kilometerstand = 0;
}
Du kannst Konstruktoren überladen, indem du unterschiedliche Parameterlisten definierst. Für einen Gebrauchtwagen lässt sich der vorhandene Kilometerstand direkt beim Erzeugen übergeben:
java
Auto(int kilometerstand) {
this.kilometerstand = kilometerstand;
}
Konstruktoren miteinander verknüpfen
Wenn mehrere Konstruktoren dieselben Attribute setzen, kannst du den gemeinsamen Code an einer Stelle halten. In Java ruft ein Konstruktor mit this(...) einen anderen Konstruktor derselben Klasse auf:
java
Auto() {
this(0);
}
Auto(int kilometerstand) {
this.kilometerstand = kilometerstand;
}
Beim Aufruf von new Auto() wird dadurch der Konstruktor mit dem Kilometerstand 0 ausgeführt. Ändert sich die gemeinsame Logik, bearbeitest du nur eine Stelle.
Als Faustregel empfehle ich dir, einen Konstruktor mit weniger Parametern den Konstruktor mit mehr Parametern aufrufen zu lassen. Dabei übergibt er die passenden Standardwerte.
Kapselung und Geheimnisprinzip
Eine Klasse fasst ihre Attribute mit den zugehörigen Methoden zu einer Einheit zusammen. Das bezeichnet Kapselung. Beim Geheimnisprinzip hält die Klasse ihre internen Werte verborgen und kontrolliert, wie andere Klassen darauf zugreifen dürfen.
Am Kilometerstand lässt sich der Zweck erkennen: Ein direkter Zugriff von außen könnte einen negativen Wert erlauben oder dazu führen, dass jemand den Kilometerstand eines Gebrauchtwagens zurücksetzt. Über Sichtbarkeitsmodifizierer legst du fest, welche Klassen auf Attribute und Methoden zugreifen dürfen.
Sichtbarkeit in Java
| Sichtbarkeit | Zugriff möglich für |
| — | — |
| private | Die definierende Klasse selbst |
| package-private | Die Klasse selbst und alle Klassen im selben Package |
| protected | Die Klasse selbst, Klassen im selben Package sowie Subklassen außerhalb des Packages |
| public | Alle Klassen |
Package-private entsteht, wenn du den Sichtbarkeitsmodifizierer weglässt. Dafür gibt es in Java ein eigenes Verhalten, aber kein Schlüsselwort. Ober- und Unterpackages zählen jeweils als andere Packages.
Bei Vererbung kann beispielsweise die Klasse Cabrio von Auto abgeleitet sein. Mit protected erhalten Subklassen Zugriff auf die entsprechend geschützten Member.
Für deinen Einstieg empfehle ich dir, Attribute und Methoden zunächst auf private zu setzen. Anschließend erweiterst du den Zugriff gezielt dort, wo deine Klasse ihn braucht.
Package-private kann zusammengehörigen Klassen innerhalb eines Packages Zugriff auf interne Member geben, etwa in einem Framework. Auch Testklassen im selben Package können so auf entsprechend zugängliche Methoden zugreifen. Ich habe dafür in meiner Praxis bislang keinen Bedarf gehabt und empfehle, private Methoden nicht direkt zu testen.
Instanzvariablen vollständig initialisieren
Wenn du eine Klasse programmierst, kennst du ihre internen Abläufe und die Bedingungen für gültige Werte. Dieses Wissen gehört in die Klasse. Andere Entwickler:innen sollen mit einem neu erzeugten Objekt arbeiten können, ohne erst eine bestimmte Folge von Setter-Aufrufen kennen zu müssen.
Java und C# erzwingen eine solche Folge späterer Methodenaufrufe nicht. Deshalb muss deine Klasse selbst dafür sorgen, dass notwendige Schritte in der richtigen Reihenfolge stattfinden, einschließlich erforderlicher Berechnungen oder Datenbankzugriffe.
Du kannst einen festen Anfangswert direkt bei der Deklaration setzen:
java
private int kilometerstand = 0;
Im Konstruktor lässt sich der Wert ebenfalls zuweisen, beispielsweise anhand eines übergebenen Parameters. Für komplexere Berechnungen kannst du eine eigene Methode schreiben, die das Attribut setzt. Der Konstruktor muss diese Methode dann aufrufen, damit das Objekt anschließend einen gültigen Zustand hat.
Wann du this beim Zugriff brauchst
Bei einem eindeutigen Attributnamen kannst du innerhalb der Klasse direkt kilometerstand = 0; schreiben. Hat ein Parameter oder eine lokale Variable denselben Namen, wird dieser Name im näheren Gültigkeitsbereich verwendet.
Im folgenden Konstruktor bezeichnet kilometerstand den Parameter. Über this.kilometerstand sprichst du ausdrücklich das Attribut des aktuellen Objekts an:
java
Auto(int kilometerstand) {
this.kilometerstand = kilometerstand;
}
Du kannst den Parameter auch neuerKilometerstand nennen. Dann ist mit kilometerstand = neuerKilometerstand; eindeutig, welcher Wert welchem Attribut zugewiesen wird.
Weiterführendes Material
Unter anwendungsentwicklerpodcast.de/44 habe ich einen Oracle-Tutorialartikel mit einer Matrix zu den Sichtbarkeiten verlinkt. Dort findest du auch die Literaturempfehlungen "Einführung in Java" und "Java ist auch eine Insel". Getter und Setter sowie das Single Responsibility Principle sind für eine folgende Folge vorgesehen.
Transkription der gesamten Episode
Automatisch erzeugte Transkription der Episode
Herzlich willkommen zum Anwendungsentwickler-Podcast, dem Podcast rund um die Ausbildung zum Fachinformatiker
für Anwendungsentwicklung. In dieser Episode geht es um eine weitere Lernzielkontrolle zum Thema Objektorientierung. Viel Spaß!
Hallo und herzlich willkommen zur 44. Episode des Anwendungsentwickler-Podcasts.
Mein Name ist Stefan Mackel und heute kommt Nummer 2 meiner Lernzielkontrollen zum Thema Objektorientierung.
Beim letzten Mal, was ja schon jetzt etwas länger her ist, weil ich über die Jahreswende eine kleine Pause gemacht habe, für alle, die das später hören,
dieser Podcast erscheint im Januar 2016 und über Weihnachten habe ich mir mal ein paar freie Tage gegönnt und habe keine Podcast-Episode aufgenommen.
Aber jetzt kommt der zweite Teil meiner Lernzielkontrolle zum Thema Objektorientierung.
Beim letzten Mal hatten wir uns ja schon mit den Basics auseinandergesetzt, so Klasse und Objekt und Methode und Attribute und so weiter.
Und jetzt gehen wir nochmal auf ein paar weitere Sachen ein, die auch so im Verlauf meines Java-Tutorials, was ich immer mit meinen Studenten und Azubis durchgehe,
jetzt als nächstes käme. Also ich habe ja die Lernzielkontrollen so ein bisschen so aufgebaut, dass man quasi anhand des Tutorials sich selber einarbeiten kann
und dazu passend dann die Podcast-Episode hören kann. Das Tutorial gibt es leider noch nicht irgendwo zum Download.
Habe ich schon ein paar Anfragen bekommen, aber das ist, sage ich mal, noch geheim, weil es sich nicht in einem Zustand befindet,
wo ich das Ganze jetzt nach draußen geben könnte oder wollte.
Aber meine Studenten und Azubis lernen damit und ich habe die Erfahrung gemacht, dass es auch einige andere Azubis gibt,
die anhand dieser fortschreitenden Lernzielkontrollinhalte hier so ein bisschen auch in die Java-Entwicklung einsteigen.
Und deswegen führe ich das jetzt mal so ein bisschen fort.
Ja, was haben wir beim letzten Mal gelernt? Klasse, Objekt hatten wir uns darüber unterhalten.
Objekt ist nichts weiter als eine Instanz einer Klasse.
Und da gibt es jetzt so ein schönes kleines Schlüsselwörtchen, mit dem Objekte auf ihre eigenen Member zugreifen können,
also auf ihre eigenen Attribute und oder Methoden.
Und das ist das Schlüsselwort Vis.
Das gibt es in sehr vielen objektorientierten Sprachen, selbstverständlich auch in Java und auch in C Sharp und verschiedenen anderen Programmiersprachen.
Und das Vis ist einfach nur eine Referenz auf das aktuelle Objekt.
Ich erkläre das immer so, wenn man sich so ein bisschen den Code vorstellt.
Ich nehme mal das Standardbeispiel Auto.
Ich habe eine Klasse Auto und erzeuge ein neues Auto.
Wie sieht da mein Code aus? In Java würde ich sowas schreiben wie Auto A gleich New Auto.
Und dann kann ich ja im weiteren Verlauf meines Programms über die Referenz A auf mein Auto zugreifen.
Das heißt, diese Variable, die ich da definiert habe vom Typ Auto, die hat den Namen A.
Und über das A kann ich jetzt auf die Member des Objekts zugreifen.
Jetzt ist es aber so, wenn ich innerhalb der Klasse auf die Member zugreifen möchte,
dann habe ich ja eigentlich gar keinen Namen, über den ich auf meine eigenen Sachen zugreifen kann.
Denn dieser Name wird ja extern definiert.
Ja, das ist so ein bisschen eine Erklärung, die würde ich also in einer offiziellen Prüfung nicht abgeben.
Aber wenn man so Einsteiger ist, finde ich, kann man das ganz gut erklären.
Von draußen mache ich sowas wie Auto A und kann dann über A.getGeschwindigkeit darauf zugreifen.
Aber innerhalb der Klasse selber, wenn zum Beispiel eine Methode die eigene Geschwindigkeit des eigenen Objekts abfragen möchte,
über was für einen Namen soll sie das tun? Das Objekt hat ja gar keinen Namen.
Es wurde ja nicht instanziiert, sondern wir befinden uns ja gerade in der Klasse selbst
und wollen jetzt auf unsere eigenen Elemente quasi zugreifen.
Und das muss ich jetzt irgendwie tun über irgendeinen Namen.
Aber wie gesagt, das Objekt hat eben keinen Namen und ich kann mir auch nicht einfach einen ausdenken,
sondern ich brauche irgendeinen, will man sagen, so einen Pseudonamen, um auf mich selbst zu zeigen.
Das ist im Prinzip das Schlüsselwort This.
Über This kann ich auf mich selbst zugreifen.
Wenn ich in der Objektorientierung mich bewege, dann sage ich immer ganz oft,
denk doch mal, wie es ist, wenn du jetzt so ein Objekt wärst.
Also was wäre, wenn du ein Auto wärst?
Was würdest du gerne tun? Du würdest zum Beispiel gerne deinen Kilometerstand wissen
oder vielleicht den Motor starten oder deine Tür öffnen oder was auch immer.
Und das musst du ja irgendwie tun können.
Du musst dir selber einen Befehl geben können oder eine Nachricht schicken können.
Und das machen wir halt eben über das This.
Da würde ich jetzt also innerhalb meiner Klasse schreiben so etwas wie This Punkt Kilometerstand plus gleich 1,
wenn ich zum Beispiel einen Kilometer weitergefahren bin.
Und mehr oder weniger das war es eigentlich.
Also so erkläre ich das immer so für Einsteiger.
Und wenn man das dann in der Prüfung zum Beispiel erklären müsste, würde ich halt eben sagen,
es ist eine Referenz auf das aktuelle Objekt.
Das heißt natürlich auch, dass das This in jeder Klasse auf ein anderes Objekt zeigt.
Also das This bezieht sich immer auf das Objekt der Klasse, in der ich mich gerade bewege.
Ich kann jetzt also nicht von draußen irgendwo auf das This eines Autos zugreifen,
sondern nur das Auto selber kann diesen Namen This benutzen.
Niemand von draußen kann das irgendwie aufrufen.
Dann beziehe ich mich immer auf die Klasse, in der ich mich dann befinde.
Also wenn ich meinetwegen in meiner Autowaschanlage das Wort This benutze,
dann bezieht sich das This auf das Objekt der Autowaschanlage und nicht des Autos.
Das müsste natürlich dann klar sein.
Gut, warum fange ich mit dem This an?
Wir fangen noch ein ganz anderes Thema jetzt an, und zwar die Konstruktoren.
Und dabei ist das This eines der Schlüsselwörter, das man mal so brauchen kann.
Warum, gucken wir uns gleich an.
Also das müsste jetzt klar sein. Kommen wir jetzt zum Konstruktor.
Was ist überhaupt ein Konstruktor?
Ein Konstruktor ist nichts weiter als eine besondere Form von Methoden.
Der verhält sich ganz genau wie andere Methoden.
Da kann ich alles Mögliche drin programmieren, was ich auch in normalen Methoden programmieren kann.
Aber er hat einen ganz besonderen Aufbau und eine bestimmte Aufgabe.
Und zwar ist die Hauptaufgabe eines Konstruktors zunächst einmal, ein Objekt zu erzeugen.
Und das füge ich immer direkt daran an, es in einen gültigen Zustand zu versetzen.
Denn ein Konstruktor, den würde mir Java sogar im Zweifel einfach generieren, wenn ich ihn nicht selber programmieren würde.
Weil ich ja irgendwie ein Objekt einfach erzeugen muss.
Und da würde Java sogar im Hintergrund einen sogenannten Default-Konstruktor für mich generieren, wenn ich keinen angebe.
Damit überhaupt mein Programm mit den Objekten dieser Klasse arbeiten kann.
Denn wenn es kein Objekt erzeugen kann in einer Klasse, dann kann es ja mit dieser Klasse auch eigentlich nichts anfangen.
Von daher ist so ein Konstruktor eigentlich immer da, egal ob ich ihn selber schreibe oder er für mich generiert wird.
Aber die Aufgabe, die so ein Konstruktor jetzt hat, ist nicht damit erledigt, einfach nur ein Objekt zu erzeugen.
Denn dann bräuchte ich gar keinen Konstruktor.
Wie gesagt, der kann sogar auf Knopfdruck generiert werden.
Was viel wichtiger ist, ist, dass der Konstruktor dieses Objekt in einen gültigen Zustand versetzen soll.
Was heißt das?
Das heißt, alle Attribute sollen gültige Werte haben.
Wenn ich zum Beispiel mich daran erinnere an die letzte Episode, wenn wir Instanzvariablen haben,
die werden mit ihren Standardwerten initialisiert, wenn ich sie nicht explizit selber initialisiere.
Das heißt zum Beispiel Zahlwerte haben alle den Wert 0, die Bool-Variablen haben alle den Wert false
und Strings haben zum Beispiel den Wert null.
Und jetzt ist es vielleicht nicht ganz so gut, wenn ich mit mehreren String-Variablen arbeite und die sind alle null.
Denn dann kriege ich ganz fix natürlich sowas wie Null-Pointer.
Und das will ich natürlich vermeiden.
Von daher sollte ich als Programmierer meiner Klasse darauf achten,
dass mein Konstruktor alle Attribute meiner Klasse auch in einen gültigen Zustand versetzt,
ihnen also gültige Werte gibt.
Und wenn es nur ist, dass der String zum Beispiel nicht null ist, sondern eben ein leer String.
Dadurch ist wenigstens sichergestellt, dass es nicht später irgendwo Null-Pointer gibt.
Wenn wir das jetzt also machen wollen, wollen wir das Objekt in einen gültigen Zustand versetzen.
Ich habe gerade gesagt, Zustand heißt eigentlich nichts weiter als alle meine Attribute haben gültige Werte.
Und das kann man ja auch, das liest man häufig auch in der Literatur.
Wenn man von Objekten spricht, redet man häufig auch von Zustand.
Und Zustand ist nichts weiter als eben die Gesamtheit der verschiedenen aktuellen Werte von Attributen eines Objekts.
Jetzt ist natürlich die zentrale Frage, wie definiert man jetzt so einen Konstruktor?
Das kann man jetzt nicht allgemeingültig beantworten.
Das ist so ein bisschen auch abhängig von der Programmiersprache auf jeden Fall.
Aber wenn wir jetzt mal so in klassischen Sprachen bleiben, wie Java und C Sharp,
da sieht es so aus, dass man den Konstruktor ganz normal als Methode definiert.
Allerdings hat diese Methode keinen Rückgabewert.
Das heißt, ein ganz wichtiger Bestandteil, den alle anderen Methoden immer haben müssen, nämlich den Rückgabewert,
beziehungsweise void, wenn sie keinen Rückgabewert haben, den darf der Konstruktor nicht haben.
Wenn ich den dahin schreibe, dann definiere ich tatsächlich eine ganz normale Methode, aber eben keinen Konstruktor.
Also ganz wichtig, keinen Rückgabewert angeben.
Und zweite Einschränkung, der Konstruktor muss den gleichen Namen haben wie die Klasse.
Das heißt, wenn ich eine Klasse Auto habe, dann muss mein Konstruktor auch Auto heißen.
Und zwar auch mit großem A, genauso geschrieben wie die Klasse.
Also die Signatur eines Konstruktors für die Klasse Auto würde zum Beispiel so aussehen.
Auto, Klammer auf, Klammer zu. Das wär's schon.
Also, weil es ja keinen Rückgabewert gibt und auch nicht zwangsläufig Parameter,
habe ich damit gerade jetzt einen Default-Konstruktor erzeugt, nämlich einen Konstruktor, der keine Parameter hat.
Und auch keinen Rückgabewert, den darf er ja nicht haben.
Und das ist quasi der Konstruktor, der aufgerufen wird, wenn mein Objekt jetzt erzeugt werden soll von dem Auto.
Ich kann allerdings natürlich auch mehrere Konstruktoren erzeugen.
Wie gesagt, es ist eigentlich nichts weiter als eine normale Methode.
Die könnte ich zum Beispiel auch überladen.
Das heißt, wenn ich jetzt mein Auto instanziieren möchte, dann habe ich vielleicht einen Default-Konstruktor, der keinen Parameter bekommt.
Ich kann aber vielleicht auch einen zweiten Konstruktor anlegen, wo ich einen initialen Kilometerstand mit reingeben kann.
Beispielsweise habe ich eine Gebrauchtwagenhandlung und ich möchte, wenn ich ein Auto erzeuge, schon von vornherein gleich einen Kilometerstand mitgeben.
Ich kriege ein neues Auto auf Lager und will das verkaufen.
Und ich mache jetzt irgendwo in meinem Code New Auto und gebe sofort den Kilometerstand dieses Gebrauchtwagens mit rein.
Das heißt, ich könnte einen zweiten Konstruktor definieren.
Auto in Klammern int Kilometerstand zum Beispiel.
Und dann habe ich zwei Konstruktoren.
Jetzt ist es aber so, diese Konstruktoren haben meistens sehr ähnliche Aufgaben.
Schauen wir uns mal das Beispiel an mit dem Parameterlosen und dem Konstruktor mit Kilometerstand.
In beiden Fällen wird wahrscheinlich der Kilometerstand nach Verlassen des Konstruktors einen gültigen Wert haben müssen.
Wenn wir den nämlich auf Standardwert 0 zum Beispiel lassen, ist das vielleicht nicht in allen Fällen korrekt.
Das heißt, unser Konstruktor mit Parameter wird zum Beispiel den Kilometerstand auf den übergebenen Wert setzen.
Und der Konstruktor ohne Parameter setzt ihn vielleicht auf einen Standardwert wie zum Beispiel 1 oder vielleicht wäre tatsächlich hier 0 sinnvoller.
Weil ich zum Beispiel, wenn ich ein Auto gerade hergestellt habe, weil es gerade vom Band rollt, da vielleicht den Wert 0 setzen muss, weil es ja wirklich noch gar keinen Kilometer gefahren ist.
Jetzt kann man aber überlegen, dass man natürlich dieses Setzen des Kilometerstandes nicht redundant implementieren will.
Das ist ja eine ganz wichtige Voraussetzung bei jeglicher Form von Programmierung.
Das heißt, ich möchte vielleicht meine Logik zum Setzen des Kilometerstands wiederverwenden.
Und wie könnte ich das in diesem trivialen Beispiel machen?
Naja, ich könnte den Parameter, der weniger Parameter hat, benutzen, um den anderen aufzurufen und zwar mit vordefinierten Werten, mit Konstanten bzw. mit Literalen.
Schauen wir uns mal das Beispiel an.
Mein Konstruktor mit Parameter sieht vielleicht so aus.
Auto in Klammern int Kilometerstand.
Und das Einzige, was der macht, ist this.kilometerstand gleich Kilometerstand.
Das heißt, er setzt den übergebenen Wert.
Er nimmt den übergebenen Wert und setzt die Instanzvariable auf diesen Wert.
Wenn ich mir jetzt den Default-Konstruktor angucke, der keinen Parameter hat, würde der vielleicht so aussehen.
Auto, Klammer auf, Klammer zu und dann this.kilometerstand gleich 0.
Aber dieses this.kilometerstand gleich, das ist ja jetzt eigentlich redundant.
Die Zuweisung an die Instanzvariable Kilometerstand findet in beiden Konstruktoren statt.
Und das ist eigentlich doof, denn wenn sich daran irgendwas ändern sollte, muss ich es wieder an zwei Stellen ändern.
Das wollen wir nicht.
Deswegen könnte dieser Konstruktor ganz einfach den anderen Konstruktor aufrufen und zwar mit dem konstanten Wert 0.
Das heißt, der könnte so aussehen.
Auto, Klammer auf, Klammer zu und dann rufe den anderen Konstruktor auf und übergebe ihm 0.
Und dann würde bei dem Aufruf dieses Default-Konstruktors der andere Konstruktor mit Kilometerstand aufgerufen und zwar mit dem Wert 0.
Und jetzt die Frage, wie kann denn der eine Konstruktor den anderen aufrufen?
Könnte man ja so sagen, ich gebe einfach den Namen an, also Auto.
Aber das ist leider nicht so, zumindest nicht in Java und auch nicht in C Sharp.
Hier brauche ich nämlich auch das Schlüsselwort this.
Wenn ich in einem Konstruktor einen anderen Konstruktor aufrufen möchte, dann tue ich das mit dem Schlüsselwort this.
Und dann verhält sich das this so wie eine Methode im Prinzip.
Ich mache nämlich this und dann ganz normale Klammer auf und zu und übergebe da Parameter.
Das heißt, mein Default-Konstruktor würde im Beispiel von gerade so aussehen.
Auto, Klammer auf, Klammer zu und dann this, Klammer auf, 0, Klammer zu.
Weil er eben den anderen Konstruktor mit dem Argument, mit dem konkreten Wert 0 aufruft.
Also hier brauche ich zum Beispiel zum allerersten Mal das this.
Ich kann einen anderen Konstruktor nur über this aufrufen. Eine andere Möglichkeit gibt es nicht.
Deswegen ist da schon mal dieses Schlüsselwort wieder sehr wichtig.
Also fassen wir das Ganze mal kurz zusammen.
Ein Konstruktor ist eine besondere Form von Methode.
Die erkennen wir daran, dass sie keinen Rückgabewert hat und dass sie genau den gleichen Namen hat wie die Klasse.
Der Konstruktor hat die Aufgabe, ein Objekt zu erzeugen und es in einen gültigen Zustand zu versetzen,
also insbesondere alle Instanzvariable mit korrekten Werten zu versehen.
Da hier die gleichen Regeln gelten wie bei der ganz normalen Programmierung,
versuchen wir auch unseren Code wiederzuverwenden.
Und wenn ein Konstruktor einen anderen Konstruktor aufrufen soll, um dessen Code wiederzuverwenden,
benutzen wir dafür das Schlüsselwort this.
Das this zeigt auf das aktuelle Objekt und in diesem konkreten Fall, wenn wir es in einem Konstruktor benutzen,
bedeutet das, rufe bitte einen anderen Konstruktor auf und übergebe ihm bestimmte Parameter.
Übrigens ein ganz einfacher Weg, um festzustellen, welcher Konstruktor welchen anderen aufrufen muss,
wenn ich so einen Code wiederverwenden möchte.
Für mich ist so eine Daumenregel, der Konstruktor mit weniger Parametern ruft immer den mit mehr Parametern auf.
Das ist eigentlich fast nie umgekehrt.
Also sage ich mal, für die Standardklassen kann man das eigentlich immer so rummachen.
Denn wie in unserem Beispiel gerade, der Konstruktor mit weniger Parametern setzt ja irgendwelche Standardwerte.
Wie gerade auch der Konstruktor mit Parameter, der erwartet den Kilometerstand.
Der ohne, der setzt den Kilometerstand hart auf 0.
Das heißt, es kann nur der Konstruktor ohne Parameter den anderen aufrufen.
Alles andere wäre Quatsch.
So, dann kommen wir jetzt von den Konstruktoren zu einem ganz wichtigen weiteren Teil, und zwar der sogenannten Sichtbarkeit.
Wir haben schon gelernt, dass wir in Objektorientierung ganz viel Wert auf die sogenannte Kapselung legen und auch auf das sogenannte Geheimnisprinzip.
Das wird häufig gleichwertig behandelt.
Also diese beiden Begriffe werden synonym zueinander benutzt, ist aber nicht hundertprozentig das gleiche.
Kapselung bedeutet eigentlich, dass Klassen ihre Attribute und die zugehörigen Methoden gemeinsam abbilden und damit kapseln.
Sie bilden also quasi eine Einheit, die von draußen irgendwie angesprochen und angesteuert werden kann.
Das ist eigentlich die Kapselung.
Wenn wir davon ausgehen, dass die Werte dieser Attribute nicht nach draußen einfach preisgegeben werden sollen, dann sprechen wir eigentlich vom Geheimnisprinzip.
Das heißt, die Klasse soll ihre innersten Werte, sage ich mal, geheim halten, damit da eben niemand drin rummanipulieren kann.
Das ist dann eigentlich das sogenannte Geheimnisprinzip.
Wenn wir jetzt aber genau dieses Geheimnisprinzip uns mal angucken, dann ist ja die Frage, wie kriegen wir das denn hin?
Wie kriegen wir denn hin, dass unsere Attribute in der Klasse eben nicht von allen möglichen anderen Klassen von draußen ausgelesen werden können oder noch schlimmer, manipuliert werden können?
Wenn zum Beispiel bei der Klasse Auto von draußen jemand den Kilometerstand auf minus drei setzt, das wäre ungünstig.
Das ist kein erlaubter Wert.
Oder noch schlimmer, wir haben einen Gebrauchtwagen und drehen einfach mal eben den Kilometerstand zurück, um ein bisschen mehr Geld zu verdienen.
Das ist ja schon kriminell.
Also das müssen wir auf jeden Fall verhindern.
Das darf auf keinen Fall passieren.
Nur gibt es Möglichkeiten.
Und das Ganze funktioniert über sogenannte Sichtbarkeitsmodifizierer.
Sichtbarkeit bedeutet, wie von draußen auf diese Attribute oder auch auf die Methoden, für die gilt es auch, zugegriffen werden kann.
Sind die von draußen sichtbar oder nicht?
Und sichtbar bedeutet in diesem Fall auch, wenn ich sehen kann, kann ich es auch aufrufen.
Es ist also nicht möglich, dass ich zum Beispiel eine Variable sehe, sie aber nicht verändern kann.
Das geht nicht. Sobald ich was sehen kann, kann ich auch alles damit machen.
Also sowohl lesen als auch setzen.
Das ist immer ganz wichtig.
Und ich kann jetzt bei meinen Attributen und Methoden die Sichtbarkeit einschränken.
Die Standardsichtbarkeit, wenn ich die zum Beispiel auf für alle sichtbar setzen würde, dann kann halt jeder tun und lassen mit diesen Attributen, was er will.
Er kann die setzen, lesen, illegale Werte setzen, völlig wurscht.
Und wenn ich jetzt einschränken will, dass das eben nicht mehr geht, dann muss ich diese Sichtbarkeit eben reduzieren.
Und das kann ich mit verschiedenen sogenannten Sichtbarkeitsmodifizierern tun.
Also Modifizierer ist einfach nur ein anderes Wort für Veränderer, sage ich mal.
Also die verändern die Sichtbarkeit.
In diesem Fall schränken sie sie ein, je nachdem, was für ein Wort wir hier benutzen.
Und es gibt eigentlich in der Objektorientierung klassischerweise drei Sichtbarkeitsmodifizierer.
Und zwar Private, Protected und Public.
Fangen wir mit Public an.
Public bedeutet nämlich, dass einfach jeder diese Attribute sehen kann.
Und mit jeder meine ich die Klasse selber, als auch alle anderen Klassen rundherum.
Und es ist ganz egal, ob die Klassen im gleichen Package liegen oder in einem ganz anderen Programm oder wo auch immer.
Jeder kann auf diese Attribute oder Methoden zugreifen.
Private ist das krasse Gegenteil dazu.
Das bedeutet nämlich, dass nur die Klasse, die dieses Attribut oder die Methode definiert, selbst darauf zugreifen kann.
Und niemand anderes.
Das heißt, wenn ich etwas Private setze, dann habe ich die geringst mögliche Sichtbarkeit.
Dass nur die Klasse selber die Elemente oder die Member sehen kann und damit aufrufen oder verändern kann.
Jetzt gibt es noch das Zwischending Protected.
Da müssen wir jetzt etwas vorgreifen.
Wir haben uns noch nicht über Vererbung unterhalten.
Aber ich setze es einfach mal voraus, dass du vielleicht so grob weißt, was Vererbung bedeutet.
Vererbung heißt, dass eine Klasse von einer anderen Klasse etwas erben kann.
Das bedeutet, wenn ich die Klasse Auto zum Beispiel habe, dann könnte ich eine Unterklasse, meinetwegen Cabrio, erzeugen.
Okay, das Beispiel kann niemand mehr hören.
Ich weiß es. Es fällt mir bloß kein anderes gerade ein.
Und deswegen nehme ich das jetzt einfach.
Und die Klasse Cabrio würde also von Klasse Auto alles das erben, was die Klasse Auto definiert.
Nämlich alle Attribute und Methoden.
Das heißt, wenn die Klasse Auto einen Attribut, wie hatten wir gerade, Kilometerstand hätte,
dann hätte auch die Klasse Cabrio dieses Attribut, ohne dass sie es selber nochmal definieren muss.
Und wenn wir jetzt eine Sichtbarkeit erzeugen wollen,
die sich auf die Klasse selbst und alle abgeleiteten, also alle Subklassen oder alle erbenden Klassen, beschränkt,
dann haben wir dafür das Schlüsselwort Protected, und das ist der Sichtbarkeitsmodifizierer,
der bewirkt, dass nur die Klasse selbst und alle Subklassen darauf zugreifen können.
Warum ist das sinnig?
Na ja, schauen wir uns doch mal genau das Beispiel an mit dem Auto.
Ein Cabrio wird sicherlich auch irgendwas mit seinem Kilometerstand machen wollen,
oder den wissen wollen, abfragen wollen, ändern wollen.
Aber das heißt ja noch lange nicht, dass der Mechaniker von außen auf einmal den Kilometerstand ändern können muss.
Ein Cabrio ist ja eine Form von Auto, die natürlich auch einen Kilometerstand haben muss.
Und dann ist es durchaus okay, wenn ich den einmal definiere und alle Subklassen den erben und darauf zugreifen können.
Aber das heißt noch lange nicht, dass jemand von draußen das sehen können muss.
Dafür gibt es genau diesen Sichtbarkeitsmodifizierer Protected.
Und es gibt in Java noch einen weiteren und das ist der Sichtbarkeitsmodifizierer, den ich einfach
nicht hinschreibe. Das heißt, wenn ich weder private, protected noch public vor meinen Attribut
oder meine Methode schreibe, dann ist automatisch der Standard-Sichtbarkeitsmodifizierer in Java
package-private. Also wie gesagt, dafür gibt es kein Schlüsselwort, es steht einfach nichts vor
dem Member, aber das Ding heißt eben package-private und daraus kann man schon so halb
ableiten, was das wohl bedeutet. Also der private Teil, das hatten wir gerade schon gelernt, bedeutet
eigentlich, dass nur die Klasse selbst darauf zugreifen kann. Und jetzt kommt noch etwas dazu,
und zwar alle Klassen im gleichen Package können auch noch dazu darauf zugreifen. Das bedeutet
package-private, die Klasse selbst und alle Klassen im selben Package. Und davon ausgenommen
sind auch zum Beispiel Subpackages. Es geht also wirklich nur um die Klassen, die im selben Package
liegen, weder in dem Ober- noch in dem Unterpackage. Es muss dasselbe Package sein. Wann ist das mal ganz
sinnvoll? Naja, ist vielleicht so, wenn ich meine Logik in meinem Programm auf mehrere Klassen
verteile und die zusammengehörige Logik zum Beispiel auch in einem Package gruppiere, dann
kann es vielleicht mal einen Grund geben, dass die eine Klasse auf die Attribute der anderen
zugreifen können soll, aber eben keiner aus irgendeinem anderen Package, wie zum Beispiel
aus den Packages meiner Kollegen, die mit meinem Package arbeiten. Oder wenn ich zum Beispiel ein
Framework entwickle, wo ich intern schnell auf bestimmte Dinge zugreifen können muss, aber ich
nicht will, dass Leute, die das Framework benutzen, jemand Externes auf einmal diese Interna da
abfragen kann, dann könnte ich dieses package-private benutzen. Ganz ehrlich, ich empfehle es
Programmier-Einsteigern immer, das nicht zu benutzen. Ganz einfache Daumenregel für Einsteiger,
macht alles private. Denn private ist ja, wie gesagt, die kleinstenmögliche Sichtbarkeit und
damit schränke ich erstmal alles ein und dann gucke ich selektiv, welche Attribute ich nach
draußen preisgeben möchte, beziehungsweise wem ich das auch preisgeben möchte. Kann ja sein,
dass die Subklassen das lesen müssen, aber zum Beispiel die Außenwelt nicht. Oder es muss
vielleicht wirklich durch die gesamte Welt lesbar sein. Das ist ja dann vielleicht auch okay, dann
setzt man das halt um. Aber erstmal würde ich alles auf private setzen, um auf Nummer sicher
zu gehen. Und das package-private finde ich so ein bisschen unschön einfach. Es gibt zum Beispiel
den Ansatz, dass man sowas macht, wenn man Tests schreibt. Automatische Tests, die meine Klasse
testen sollen. Und wenn ich diese Tests in selbe Package packe, dann kann ich halt auch auf die
internen Sachen zugreifen, wie zum Beispiel irgendwelche private Methoden, wo vielleicht
auch Logik drin ist und die möchte ich testen, dann kann ich das über package-private machen.
Dann kann niemand von draußen die Methode aufrufen, aber mein Test, meine Testklasse,
die kann sehr wohl diese private Methoden aufrufen. Ich persönlich bin der Meinung,
dass man private Methoden nicht testen sollte. Warum, werden wir vielleicht später noch mal
klären in einer separaten Episode. Von daher würde ich sagen, package-private ist völlig
überflüssig. Ich habe so gut wie nie einen Ansatz gefunden, um irgendwo package-private
mal einzusetzen. Wenn du einen Ansatz schon mal hattest oder das sogar selber schon mal
brauchtest, dann schreib mir doch einfach einen Kommentar. Ich lasse mich immer gerne
eines Besseren belehren. Ich habe in meiner Laufbahn package-private noch nie einsetzen
müssen. Also ich fand es noch nie sinnvoll, das irgendwo einzusetzen. Ich konnte es immer auch
anders lösen. So, jetzt wissen wir also, wie wir die Sichtbarkeit unserer Member einschränken
können und damit eben das Geheimnisprinzip umsetzen können. Also es gibt private, protected,
package-private, public. Und man kann sich da so eine schöne Matrix auch mal aufmalen. Also
ich fange immer mit dem geringstmöglichen an, nämlich private. Private heißt, nur die Klasse
selbst kann es lesen. Das nächste wäre package-private. Das bedeutet, die Klasse selbst
und alle Klassen im gleichen Package können es lesen. Dann kommt protected. Protected bedeutet,
dass die Klasse selbst, die Klassen im gleichen Package und alle Subklassen, auch wenn sie außerhalb
des Packages liegen, darauf zugreifen können. Und public letztlich bedeutet dann eben, dass
jeder darauf zugreifen kann. Völlig egal, ob Subklasse, externes Package, wo auch immer. Da
kann wirklich jeder darauf zugreifen. Und ich habe in den Shownotes zur Episode auch noch mal
einen Tutorial-Artikel von Oracle verlinkt, wo so eine kleine Matrix sichtbar ist, wer was wie
lesen kann. Das kann man sich mal einmal anschauen, dann wird das Ganze noch ein bisschen deutlicher.
Einfach mal in die Shownotes gucken, da ist das Ding verlinkt. So, jetzt haben wir also gelernt,
wie man diese Sichtbarkeit einschränken kann. Dann machen wir noch ein bisschen weiter mit
unseren Instanzvariablen. Eine Frage, die man noch stellen könnte, wäre, wie man Instanzvariablen
jetzt überhaupt initialisiert? Wir haben ja schon gelernt, wenn wir sie nicht initialisieren,
kriegen sie ihren Standardwert. Wir sollten aber ja jetzt eigentlich verhindern, dass das geschieht,
sondern wir sollten uns darum kümmern, dass sie vernünftige Werte bekommen. Das ist eigentlich
unsere Aufgabe als Programmierer einer Klasse, dass man nicht ein Objekt erzeugen kann, das eben
ungültige Werte enthält. Denn dann kriege ich vielleicht später irgendwo Fehler oder Abbrüche
in meinem Code oder wie auch immer. Und ich weiß gar nicht, warum. Ich habe einfach eine Klasse
benutzt und derjenige, der diese Klasse programmiert hat, hat Mist gebaut und hat nicht dafür gesorgt,
dass seine Klasse gültig ist. Und dann muss ich als Entwickler, der diese Klasse einfach nur benutzen
will, noch irgendwie wissen, was ich denn mit der Klasse alles machen muss. Also Beispiel,
ich muss so ein Auto erzeugen und ich muss danach dem newAuto noch sowas machen, wie set
Kilometerstand, set Motor, set Reifen oder was auch immer. Sonst kann ich mit der Klasse gar
nichts anfangen. Und das wäre blöd. Denn das bedeutet, ich muss wissen, dass ich diese setter
zum Beispiel aufrufen muss. Und wenn ich das nicht weiß, wovon ich jetzt einfach erst mal
ausgehe, weil ich die Klasse ja gar nicht kenne, dann kann Java oder meine andere Programmiersprache,
mit der ich arbeite, mich dabei auch nicht unterstützen. Die sagt ja nicht, hey, wenn du
ein Auto erzeugst, dann musst du danach aber bitte noch diese 37 setter hier aufrufen. Das
kann ich im Code nicht hinterlegen. Es gibt keine Möglichkeit, in meiner Programmiersprache zu
erzwingen, dass eine bestimmte Methode aufgerufen werden muss. Das geht einfach nicht. Das kann
eine Programmiersprache nicht abbilden. Jedenfalls nicht die, in denen wir uns gerade bewegen. Also
Java oder C Sharp zum Beispiel. Und auch Ruby, PHP oder sonst was. Das geht einfach nicht. Ich
muss eine Methode nicht aufrufen. Das ist mir als Entwickler immer freigestellt. Wenn ich aber,
um ein gültiges Objekt zu bekommen, fünf verschiedene Methoden hintereinander, am besten
auch in der richtigen Reihenfolge, aufrufen muss, dann ist das ein Wissen, was ich einfach
nicht vermitteln kann in meiner Programmiersprache. Und das muss ich als Programmierer meiner eigenen
Klassen innerhalb der Klasse regeln. Also wenn zum Beispiel beim Initialisieren eines Objekts
eine bestimmte Reihenfolge beim Initialisieren der Werte eingehalten werden muss und es muss
noch was berechnet werden und hier muss noch was aus der Datenbank gelesen werden und so weiter
und so fort, dann ist das bitte meine Aufgabe, dass zum Beispiel der Konstruktor der Klasse
das eben tut und nicht irgendein Entwickler von draußen das wissen muss und aufrufen muss. Dann
ist ja die Gefahr sehr, sehr groß, dass eben jemand das eben falsch macht, weil er was vergessen
hat oder das gar nicht überhaupt gar nicht wusste, dass er es machen muss. Und schon gibt es
irgendwo einen Programmfehler und das wollen wir natürlich nicht. Also ich bin dafür zuständig,
ich als Entwickler muss dafür sorgen, dass mein Objekt in einem gültigen Zustand ist. Und da gibt
es jetzt eigentlich verschiedene Möglichkeiten, wie ich das tun kann. Ich kann meine Instanzvariablen
direkt inline bei der Deklaration initialisieren, also wie wir das auch schon von früheren Episoden
kennen. Wenn ich irgendwo sage, private Int Kilometerstand gleich 0, das bedeutet, dass
jedes Auto erstmal mit Kilometerstand 0 beginnt. Wir können den Kilometerstand aber auch im
Konstruktor setzen, also wie wir es gerade hatten, Auto, Klammer auf, Klammer zu, This Punkt, Kilometerstand
gleich 0. Das würde auch gehen. Ich kann den Kilometerstand aber auch in einer Methode setzen,
das muss nicht im Konstruktor sein. Ich sollte dann aber natürlich darauf achten, dass der
Konstruktor diese Methode auch aufruft, sonst wäre es natürlich doof. Also wenn ich den Kilometerstand
zum Beispiel erst ganz komplex aus irgendwelchen Algorithmen berechnen muss, warum auch immer ich
das tun sollte, aber das sei jetzt mal dahingestellt, dann kann ich natürlich diese Berechnung zum
Beispiel auch in eine Methode auslagern und das muss nicht innerhalb des Konstruktors stattfinden.
Und ich kann sehr wohl auch die Initialisierung der Kilometerstandvariable in eine andere Methode
packen. Ich könnte ja sowas tun wie Auto, Klammer auf, Klammer zu und dann This Punkt berechne
Kilometerstand. Und in berechne Kilometerstand mache ich dann meine ganz komplexe Berechnung
und mache am Ende dann This Punkt Kilometerstand gleich Berechnungsergebnis. Dann hat diese
Methode die Instanzvariable initialisiert und der Konstruktor hat das Ding einfach nur aufgerufen.
Wie auch immer ich das mache, egal ob inline, im Konstruktor oder in einer Methode, ich muss
dafür sorgen, dass alle Attribute gültige Werte bekommen. Ich wiederhole es nochmal, weil das so
wichtig ist, gerade für Einsteiger. Die haben häufig dann Probleme mit halbfertigen Klassen,
sage ich mal, wo irgendwelche Werte komisch sind und sie finden dann nicht raus, warum. Und das
liegt dann eigentlich immer daran, dass die Klasse sich selbst nicht vernünftig initialisiert, weil
der Konstruktor nicht ausimplementiert wurde. Und deswegen denkt bitte daran, du bist dafür
verantwortlich, dass deine Klasse vernünftig funktioniert. Niemand anderes. Du bist derjenige,
der diese Klasse unter Kontrolle hat und du bist auch der einzige, der weiß, wie die Klasse
funktioniert und welche Werte wie gesetzt werden müssen, damit sie funktioniert. Also dieses Wissen
wollen wir nicht an irgendwelche fremden Leute geben. Die haben dafür keine Zeit. Die wollen das
auch nicht wissen. Die sollen das auch gar nicht wissen. Das müssen wir als Entwickler einer Klasse
selber machen. So, jetzt habe ich über den Zugriff auf die Instanzvariablen schon gesprochen und immer
das Schlüsselwörtchen WISS davor benutzt. Der Konstruktor hat z.B. WISS.Kilometerstand gleich
0 gemacht. Eine wichtige Frage wäre jetzt noch, ob man das WISS denn jetzt eigentlich immer braucht,
wenn ich auf Instanzvariablen zugreifen möchte. Und die Antwort ist, nö, braucht man nicht. Ich
kann also mit dem Konstruktor von eben auch machen AUTO, Klammer auf, Klammer zu und dann
Kilometerstand gleich 0. Ich brauche das WISS nicht. Ich brauche das WISS nur dann, wenn es eine
lokale Variable oder einen Parameter gibt, der den gleichen Namen hat wie meine Instanzvariable.
Also das Beispiel des zweiten Konstruktors. AUTO, Klammer auf, IND, Kilometerstand, Klammer zu. Jetzt
habe ich ein Problem, denn es gibt die Instanzvariable Kilometerstand, aber es gibt auch
den Parameter Kilometerstand. Die haben den gleichen Namen. Und wie soll ich jetzt unterscheiden,
welche ich meine? Wenn ich in meinem Konstruktor jetzt Kilometerstand eintippe, dann wird der
Konstruktor auf den Parameter zeigen. Denn der Parameter ist quasi näher dran definiert als
die Instanzvariable. Die ist ja quasi auf der nächsthöheren Ebene. Die ist einen Block höher.
Die Methode, also der Konstruktor, hat die Variable Kilometerstand. Die ist in seinem Scope,
in dieser Methode in dem Konstruktor gültig. Und in dem Scope da drüber, nämlich in dem der Klasse,
da ist die andere Variable definiert. Und weil der Scope des Parameters quasi dichter dran ist,
gewinnt diese Variable. Wenn ich jetzt aber aus diesem Scope heraus die Instanzvariable
ansprechen möchte, dann muss ich das irgendwie so unterscheiden können. Dann reicht jetzt also
nicht die eine Variable Kilometerstand, sondern jetzt muss ich sagen, hey, ich meine die Variable
Kilometerstand der Klasse und nicht den Parameter. Und das kann ich jetzt nur tun, indem ich eben das
This davor schreibe, weil This eben auf das aktuelle Objekt zeigt. Und dann ist ganz eindeutig
die Instanzvariable damit gemeint. Also sieht dann ganz häufig in Konstruktoren eben der Aufruf so
aus. This Punkt Kilometerstand gleich Kilometerstand. Ich könnte mir das This auch sparen, indem ich
den Parameter einfach umbenenne. Das ist auch so ein etwas anderer Stil, den ich häufig sehe. Wenn
ich dann den Parameter meinetwegen nenne neuer Kilometerstand, dann ist es natürlich im Konstruktor
einfacher. Dann mache ich einfach Kilometerstand gleich neuer Kilometerstand. Gibt ja keinen
Konflikt und dann brauche ich auch das This nicht. Also, kurz zusammengefasst, das This brauche ich
nur dann, wenn es einen Namenskonflikt gibt. Dann muss ich das vor den Namen der Instanzvariable
schreiben, damit ich das eben eindeutig ansprechen kann. So, ich schaue mal auf die Uhr und stelle
fest, dass ich gleich in der ersten Episode des neuen Jahres schon wieder überziehen würde,
wenn ich jetzt nicht aufhören würde. Und deswegen tue ich genau das. Ich beende die Episode jetzt
und verschiebe den Rest, den ich noch vorhabe, nämlich Getter und Setter und das Single
Responsibility Principle und so weiter. Die machen wir dann beim nächsten Mal. Wir brechen jetzt hier
erstmal für heute ab. Und wenn du die Shownotes dir anschauen willst, dann kannst du das wie
immer tun unter anwendungsentwicklerpodcast.de slash 44, also zweimal die 4. Dort gibt es zum
Beispiel den Link zu dieser kleinen Matrix mit Private, Protected und so weiter, wer wann wie
darauf zugreifen kann. Und noch ein paar kleine andere Sachen. Die Literaturempfehlung ist eigentlich
wie immer schon zur LZK hier meine, also nicht meine, aber das Buch Einführung in Java,
beziehungsweise auch die Java-Insel, ist wie immer auch hier wieder in Shownotes verlinkt. Kann ich
nur empfehlen. Da wird das natürlich auch alles im Detail nochmal besprochen, was ich heute hier
erzählt habe. Wie immer der Aufruf, wenn du Feedback hast, dann schreib mir doch gerne eine Mail,
zum Beispiel at mail at anwendungsentwicklerpodcast.de oder noch besser als Kommentar zur Episode. Dann
haben auch andere was davon und du kannst mich auch unter allen möglichen Social Networks erreichen,
wenn du magst, unter anwendungsentwicklerpodcast.de slash und dann zum Beispiel iTunes, Stitcher,
Facebook, Twitter, Xing. Einfach dahinter schreiben und dann wirst du normalerweise sofort
umgeleitet auf die entsprechende Seite, wo du gerne mit mir in Kontakt treten kannst,
wenn du magst. Ansonsten würde ich dir empfehlen, abonniere den Podcast doch im Feed. Auf der Website
ist der RSS-Feed verlinkt. Du kannst aber auch in den üblichen Podcast-Anwendungen einfach mal
nach dem Podcast suchen, dann verpasst du keine neue Episode. Kommen ja immer Montags raus,
die kriegst du dann direkt zum Beispiel aufs Handy. So mache ich es mit meinen Podcasts immer.
Sind dann gleich Montags morgens um 6 Uhr auf dem Handy bereit für den Weg zur Arbeit. Und zuletzt,
wie immer, der Hinweis auf meinen Newsletter unter anwendungsentwicklerpodcast.de slash
Newsletter. Da kannst du den abonnieren. Da kriegst du gleich Zugriff auf meine Checklisten
rund um die wichtigen Artefakte der Projektarbeit und du kriegst einmal die Woche alle Neuigkeiten
von der Website und auch die Links der Woche gibt es immer schon vorab. Damit sage ich jetzt
vielen, vielen Dank fürs Zuhören und bis zum nächsten Mal. Tschüss!











Neueste Kommentare