Speicherzustände Java?
Guten Tag,
ich habe ein kleines Problem mit dem Verständnis mit Speicherzuständen in Java.
Und zwar zeichne ich als Übung ein Diagramm mit verschiedenen Pointern.
Die Aufgabe ist diese:
Code:
public class HSeiteneffekte {
public static void main(String[] args) {
Wrapper w1 = new Wrapper();
Wrapper w2 = w1;
w1.setI(1);
w2.setI(2);
int x = 3;
int[] a = { 1, 2 };
f(w1, x, new int[] { 4, 5 });
f(w2, x, a);
// Speicherzustand hier zeichnen
}
public static void f(Wrapper w, int x, int[] a) {
// Speicherzustand hier zeichnen
x = a [0];
a [0] = w.getI();
w.setI(x);
}
}
public class Wrapper {
private int i;
public void setI(int x) {
i = x;
}
public int getI() {
return i;
}
}
Es wird nun die Methode main ausgeführt. Stellen Sie den Speicher (d.h. alle (implizit) im Programm vorkommenden Arrays (außer args) und Objekte) bei jedem Aufruf der Methode f und vor Ende des Programms graphisch dar.
Es müssen also insgesamt drei Speicherzustände dargestellt werden.
Unten habe ich mein Ansatz bzw meine Lösung gepostet.
Wäre das denn richtig oder sollte ich bei 1) Speicherzustand nur ein Array (int[]) und nur ein Objekt (Wrapper) haben?
Falls ich irgendwo einen Fehler gemacht habe, könntet ihr mich aufklären? Das wäre sehr lieb, weil ich das Thema wirklich verstehen möchte.
Danke im Voraus.
1 Antwort
Deine Bilder sind zu klein, als dass ich darauf etwas erkennen könnte. Darauf gehe ich an dieser Stelle also nicht ein.
Vorbereitung:
Diese Zeilen:
Wrapper w1 = new Wrapper();
Wrapper w2 = w1;
// ...
darf man erst einmal nicht übersehen. Im Grunde wird ein neues Objekt des Typs Wrapper erstellt und eine Variable w2, die folgend auf dasselbe Objekt verweisen soll, wie w1. Egal nun, über welche der beiden Variablen eine Änderung vorgenommen wird, es ist stets dasselbe Objekt betroffen. Erst bei einer Neudefinition von einer der beiden Variablen, würde es zu einem Bruch kommen. Näheres dazu weiter unten.
Was passiert in der Methode f:
Beim ersten Aufruf werden ihr der Wrapper (mit i=1), die 3 und das Array { 4, 5 } übergeben. In Java sind alle Werteübergaben by value. Das bedeutet, der Parameter x mag zwar den Wert 3 haben, doch diese 3 ist nur eine Wertekopie der Variable x von außerhalb. Wenn sich x in der Methode verändert, verändert sich die Variable x außen nicht.
Im ersten Schritt wird der Parameter x also mit einem neuen Wert (4) überschrieben.
x = a[0];
Dann wird der aktuelle Wert von dem Attribut des Wrapper-Objekts geholt (2) und im Array an erster Stelle gespeichert.
a[0] = w.getI();
Abermals handelt es sich nur um eine Wertübergabe - getI liefert nur einen primitiven Wert. Sollte sich das erste Element des Arrays folgend nochmals ändern, hat das keinerlei Einfluss auf das Wrapper-Objekt. Auf die Wirkung auf das Array hingegen komme ich noch zu sprechen.
In Zeile 3 wird der Zustand des Wrapper-Objekts geändert. Das Attribut i hat danach den Wert 4.
w.setI(x);
Nun hast du ein paar Zeilen weiter oben gelesen, Parameter würden in Java stets pass by value übergeben werden. Das sollte ja bedeuten, dass von jedem Parameter immer nur eine Kopie gemacht wird, sodass auf die äußeren Objekte, die übergeben wurden, kein Einfluss besteht.
Das heißt nochmals deutlich im Klartext, man müsste bei diesem Beispiel folgendes Ergebnis erwarten:
class Car {
public int numberOfWheels = 4;
}
class ServiceStation {
public void change(Car car, int numberOfWheels) {
car.numberOfWheels = numberOfWheels;
}
}
// main:
Car car = new Car();
ServiceStation station = new ServiceStation();
station.change(car, 3);
System.out.println(car.numberOfWheels); // <<< should be 4?
Dem ist aber keinesfalls so. Die Methode change ändert durchaus den Zustand des Objekts (die neue Radanzahl wäre 3). Das liegt daran, dass Java implizit mit einer Art Zeiger je Objekt arbeitet. Einen solchen Zeiger kann man sich hierbei als ein Element vorstellen, welches auf ein Objekt zeigt.
[Variablenname] --- zeigt auf --> [Zeiger] --- zeigt auf --> [Objekt]
Über den Zeiger werden die Methoden und Attribute des Objekts ganz normal aufgelöst / angesprochen. Bei der Parameterübergabe wird implizit einfach eine Kopie des Zeigers erstellt (nicht auf das Objekt). Diese Kopie zeigt wie das Original auf dasselbe Objekt.
Würde man allerdings eine Neudefinition der Variable (bzw. des Parameters) vornehmen, würde man den ursprünglichen Zeiger nicht mehr zur Verfügung haben und auf ein neues Objekt verweisen. Ein Beispiel dazu:
class Car {
public int numberOfWheels = 4;
}
class ServiceStation {
public void change(Car car, int numberOfWheels) {
car = new Car(); // redefinition of variable
car.numberOfWheels = numberOfWheels;
}
}
// main:
Car car = new Car();
ServiceStation station = new ServiceStation();
station.change(car, 3);
System.out.println(car.numberOfWheels); // <<< 4
Tatsächlich ist für dich als Java-Programmierer zunächst nur das Verhalten interessant. Die von mir erwähnten Begriffe (pass by value) sind nur Beiwerk, welches beim Vergleich mit anderen Programmiersprachen relevanter wird. Es gibt nämlich Sprachen (wie C++ oder PASCAL), die durchaus auch noch andere Formen unterstützen.
Zuletzt noch die Lösung für den zweiten Aufruf von f:
Das x (außen) bleibt nach wie vor 3, innen nimmt es die 1 an. Durch die vorherige Änderung des Wrapper-Objekts (über w1) liegt der Attributwert anfangs bei 2 und die erste Stelle des Arrays wird mit 4 überschrieben. Das Wrapper-Objekt bekommt für sein Attribut als neuen Wert die 1 zugewiesen.
