So funktioniert die Referenzierung von Objekten in Java Programmen
Auf Java Objekte greifst du mit einer Art Fernsteuerung zu.
Diese bezeichnet man als Referenz oder als Verweis.
Und diese Referenzvariablen möchte ich dir jetzt einmal vorstellen.
Doch bevor wir loslegen, lass mich noch ein paar Dinge loswerden.
Ich habe es ja schon einmal in einem früheren Beitrag erwähnt.
Java unterscheidet zwischen primitiven und komplexen Datentypen.
Und einer dieser komplexen Datentypen sind die einzelnen Java Objekte.
Warum sind diese komplex?
Naja bei einem primitiven Datentypen reservierst du ganz klar einen bestimmten Speicherplatz und eine Speichergröße.
Bei einem Java Objekt ist es so, dass du unzählige Instanzvariablen anlegen kannst.
Und jede Instanzvariable entspricht einem bestimmten Datentyp.
Und somit hat jede Instanzvariable seinen festen Speicherplatz.
Aber da ist noch mehr….
In diesem Beitrag möchte ich dir den Umgang mit Java Objekten etwas genauer vorstellen.
Ich möchte dir diesen Umgang mit Hilfe einer Metapher näher bringen, welche ich in dem großartigen Buch „Java Kopf bis Fuß*“ gesehen habe.
Inhalt
Java Objekte besitzen eine Fernbedienung.
Du kennst das….
Du sitzt vor deinem Fernseher und zappst durch die Programme.
Du hältst also deine Fernbedingung in der Hand und schaltest um.
Somit hast du einen Zugriff auf deinen Fernseher, ohne diesen wirklich zu berühren.
Ist doch erst einmal eine coole Sache, oder?
Und genauso kannst du dir den Zugriff auf Java Objekte vorstellen.
Du berührst diese niemals. Du greifst auch nicht selbst auf diese Objekte zu.
Du bedienst lediglich eine Fernbedingung und steuerst die Objekte damit.
Und so ein Konzept nennt man in der Programmierung Referenzierung.
Und deshalb bezeichnet man Java Objekte auch als Referenzvariablen.
Objekte werden somit niemals direkt angesprochen, sondern lediglich über einen Verweis bzw. Referenz.
Oder wie ich es nenne – eine Fernbedienung.
Um diese Referenzen zu verdeutlichen, lass uns einmal ein paar Java Objekte anlegen.
Ich finde das Beispiel mit Fernseher und Fernbedienung ganz anschaulich.
Und deshalb bleibe ich beim Fernseher.
Ich habe dazu eine Klasse namens Fernseher angelegt.
Diese Java Klasse führt weiterhin eine main-Methode, um das Programm zu starten.
Und zum Programmstart werden jetzt Fernseher angelegt.
Und so sieht der Java Code dazu aus.
public class Fernseher {
public static void main(String[] args) {
Fernseher a = new Fernseher(); //Referenzvariable a verweist auf ein Java Objekt vom Typ Fernseher
}
}
Um dies in einem Bild besser und übersichtlicher verdeutlichen zu können, nenne ich meine Referenzvariablen nur a, b, c usw.
Und so kannst du dir dies bildlich vorstellen.
Die Fernbedienung a (Referenzvariable) verweist auf ein bestimmtes Fernseher-Java-Objekt.
Und jetzt kannst du verschiedene Java Objekte anlegen.
public class Fernseher {
public static void main(String[] args) {
Fernseher a = new Fernseher(); //Referenzvariable a verweist auf das erste Java Objekt
Fernseher b = new Fernseher(); // Referenzvariable b verweist auf zweites Objekt
}
}
Ganz wichtig ist die Tatsache, dass du auf alle deine Java Objekten lediglich durch die Referenzvariablen zugreifst.
Ich sage es nochmal.
Du greifst niemals selbst auf das Objekt zu.
Du hast nur die Fernbedienung.
Und beim zweiten und allen zukünftigen Objekten kannst du dir den Zugriff so vorstellen.
Somit greift die Referenzvariable a auf das erste Fernseherobjekt zu.
Und die Variable b stellt den Verweis zum zweiten Fernseherobjekt her.
Um dir zu zeigen, dass ich dir kein Mist erzähle….
Lass uns eine Instanzvariable einführen.
Ich halte es ganz einfach und nenne diese einfach mal „objektVariable“.
Und der Datentyp ist Integer.
public class Fernseher {
int objektVariable; //Instanzvariable steht beiden Objekten separat zur Verfügung
public static void main(String[] args) {
Fernseher a = new Fernseher(); //Referenzvariable a verweist auf Objekt 1
Fernseher b = new Fernseher(); //Referenzvariable b verweist auf Objekt 2
}
}
So und jetzt schalten wir die Fernbedienung für beide Objekte einfach mal ein.
Und legen für jedes Java Objekt ein separaten Wert für die Instanzvariable an.
Und zwar geschieht dies durch den Punktoperator.
Durch diese Punktnotation hast du Zugriff auf beide Instanzvariablen.
Durch das Setzen des Punktes derefenzierst du.
Das heißt: Du hast jetzt den tatsächlichen Zugriff auf das Objekt.
Und dann kannst du für jedes Java Objekt einen separaten Wert zuweisen.
Und so geht’s.
public class Fernseher {
int objektVariable; //Instanzvariable steht beiden Objekten separat zur Verfügung
public static void main(String[] args) {
Fernseher a = new Fernseher(); //Referenzvariable a verweist auf Objekt 1
Fernseher b = new Fernseher(); //Referenzvariable b verweist auf Objekt 2
a.objektVariable=1; //Zugriff auf Objekt 1
b.objektVariable=2; //Zugriff auf Objekt 2
}
}
Jetzt haben die Instanzvariablen zu jedem Java Objekt einen individuellen Wert.
Lass uns dies überprüfen.
Also lass uns die Werte der Instanzvariablen über die Bildschirmausgabe zurückgeben.
Und so sieht der Java Code dazu aus.
public class Fernseher {
int objektVariable; //Instanzvariable steht beiden Java Objekten zur Verfügung
public static void main(String[] args) {
Fernseher a = new Fernseher(); //Referenzvariable a verweist auf Objekt 1
Fernseher b = new Fernseher(); //Referenzvariable b verweist auf Objekt 2
a.objektVariable=1; //Zugriff auf Objekt 1
b.objektVariable=2; //Zugriff auf Objekt 2
System.out.println(a.objektVariable); //Rückgabe des Wertes für Objekt 1
System.out.println(b.objektVariable); //Rückgabe des Wertes für Objekt 2
}
}
Klicke auf „Run“ und dir werden unterschiedliche Werte zurückgegeben.
Falls du das Einführungsbeispiel zur Java Programmierung vollzogen hast, ist all das nicht neu für dich.
Aber du kannst für ein und das selbe Objekt auch mehrere Referenzvariablen anlegen.
Lass uns eine zweite Fernbedienungen für ein Java Objekt anlegen
Bisher haben wir zu jeder Referenzvariablen immer ein Objekt angelegt.
Wir haben also immer durch das Keywort „new“ und den Konstruktoraufruf ein Objekt erschaffen.
Wenn du allerdings nur eine Referenz anlegst, kannst du auch auf ein bereits bestehendes Objekt verweisen.
public class Fernseher {
int objektVariable; //Instanzvariable steht beiden Objekten separat zur Verfügung
public static void main(String[] args) {
Fernseher a = new Fernseher(); //Referenzvariable a verweist auf Objekt 1
Fernseher b = new Fernseher(); //Referenzvariable b verweist auf Objekt 2
Fernseher c = b; //Referenzvariable c verweist auf Objekt 2
}
}
Du besitzt nun drei Referenzvariablen und zwei Java Objekte.
Was passiert eigentlich,
wenn du jetzt den Wert der Instanzvariablen für Objekt 2 änderst?
Und wenn du dann den Wert der Instanzvariablen für b und c aufrufst und zurückgeben lässt?
Oder anders gesagt:
Du nutzt die Fernbedienung b und änderst den Wert der Instanzvariablen.
Und über Fernbedienung c lässt du dir den Wert zurückgeben.
Wird c dir den gleichen Wert zurückgeben oder nicht?
Na, was denkst du?
Lass uns einmal ausprobieren.
Hier ist der Java Code dazu:
public class Fernseher {
int objektVariable; //Instanzvariable steht beiden Objekten separat zur Verfügung
public static void main(String[] args) {
Fernseher a = new Fernseher(); //Referenzvariable a verweist auf Objekt 1
Fernseher b = new Fernseher(); //Referenzvariable b verweist auf Objekt 2
Fernseher c = b; //Referenzvariable c verweist auf Objekt 2
b.objektVariable=12; //Zuweisung des Wertes für Objekt 2 durch Fernbedienung b
System.out.println(c.objektVariable); //Rückgabe des Wertes für Objekt 2 durch Fernbedienung c
}
}
Und was kommt raus?
Na klar „12“.
B und c verweisen auf das selbe Objekt.
Wenn du einen Fernseher hast und zwei Fernbedienungen dazu.
Dann ist es egal mit welcher Fernbedienung du umschaltest.
Beide Fernbedienungen haben den gleichen Zugriff und liefern das gleiche Ergebnis.
Zusammenfassung:
- Wenn du Java Objekte anlegst, legst du gleichzeitig immer eine Referenzvariable an.
- Diese Referenzvariable stellt einen Verweis zum jeweiligen Objekt her.
- Diese Referenzvariable stellt eine Art Fernbedienung zu deinem Objekt her.
Erst durch die Punktnotation gehst du zu den Java Objekten hin und kannst diese ändern.
Über den Autor
