Wer kann mir diese Java Aufgabe erklären mit „Heap“ und „Garbage Collector“ (Siehe Foto)?
Was ist ein Heap? Was ist ein Garbage Collector?
Also das einzige was ich verstehe ist die for Schleife da wird komischer weise 10 mal ein Objekt x erzeugt und 10 mal ein Objekt y erzeugt und immer wieder überschrieben und beim 10.mal ist dann im Objekt x das a hat den Wert 10 und n auch 10 und bei Objekt y beim 10. mal hat a den Wert 11 und n den Wert 12 ist das richtig?
Und dann werden irgendwie Referenzen getauscht was das ganze total umständlich macht
Mit freundlichen Grüßen
4 Antworten
Alle Objekte, die via new erstellt werden, werden auf dem Heap abgelegt. Wenn ein Objekt keine Referenzen mehr aufweisen kann, wird es vom GC gelöscht.
Object someObject = new Object(); // Object created on heap
someObject = null; // Object will be removed
Genau, da der GC laut Aufgabe mal nicht läuft, können erst einmal nur Objekte angelegt werden und die sollst du in Teilaufgabe 1 zählen. Ob nun eine Referenz (Variable) auf die Objekte zeigt oder nicht, ist soweit nicht relevant.
Object a = new Object(); // objects = 1
a = new Object(); // objects = 2
Object b = new Object(); // objects = 3
b = a;
b = new Object(); // objects = 4
Nach Ablauf dieses Code-Snippets hättest du vier Objekte auf dem Heap. Die ersten Zwei würden später vom GC gelöscht werden.
ok ich hab die aufgaben nun gemacht kannst du kontrollieren ob das richtig ist ich gebe dann auch den Stern, also:
Bei Nummer 1: Es sind 18 Objekte nach Ablauf der Schleife Garbage
Bei Nummer 2: Nach dem Aufruf gibt es bloß 1 nicht Garbage Objekt
Bei Nummer 3: gar keine
Bei Nummer 4: Höchste Anzahl an nicht Garage Objekten ist 3
Bei Nummer 5: 2
1) Exakt. 20 Objekte werden erzeugt, nur die letzten zwei haben am Ende noch eine Referenz auf sich.
2) Das stimmt nicht. Am Ende verweisen x und z auf das Objekt in y und w verweist auf das Objekt, welches direkt nach der Schleife in der Methode f erzeugt wurde.
3) Das ist falsch. Es sind drei Variablen (x, y, z). Der letzte Schleifendurchlauf sorgt dafür, dass das Objekt in y mit den Werten 11 und 12 für die Attribute a und b ausgestattet wird. In der Methode g wiederum tauschen die Attribute die Werte und b bekommt den Wert 11.
4) Ja, ich komme auch nur auf 3. Einmal nach der Initialisierung von z und einmal nach der Initialisierung von w.
5) Das habe ich so auch gezählt. Zum einen das letzte Objekt von x in der Schleife, dann das Objekt für y im vorletzten Schleifendurchlauf (9 + 1).
Ok danke für die Kontrolle du hast den Stern 🌟 verdient 😊👍
Nochmal ne kurze Nachfrage und zwar zu Nummer 2:
Hab jetzt nochmal überlegt und das müssten dann ja im Grunde 4 "nicht Garbage Objekte" am Ende sein:
x verweist ja auf das y Objekt,
w verweist auf das z Objekt,
z verweist auf das y Objekt,
und y verweist ja nach wie vor auf sich selbst also y verweist auch auf das y Objekt,
das wären dann 4?
Nein. Das sind vier Variablen die auf insgesamt zwei Objekte zeigen.
Beispiel:
Object a = new Object();
Beim Aufruf von new wird ein Objekt im Heap angelegt. Zudem wird die Variable a definiert, die von new die Adresse für das angelegte Objekt bekommt. Sie ist in dem Moment das einzige Element, welches das Objekt noch kennt / weiß, wo es wohnt. Wenn nun noch eine zweite Variable kommt:
Object b = a;
kennen zwei Variablen die Adresse des Objekts. Wenn eine der beiden Variablen diese wieder vergisst:
a = null;
ist das nicht schlimm, denn b kennt sie ja noch.
Ahsoo ok verstanden also sind es 2 nicht garbage Objekte weil x zeigt auf y, z zeigt auf y und y zeigt auf y das zählt schon mal als 1 dann w zeigt auf z das zählt auch als 1 also insgesamt 2 oke ich glaub ich hab’s ich glaub ich hab’s endgültig verstanden danke
Der Heap ist Teil des Speichers des Programms, in dem Instanzen von Klassen, die mit new erzeugt werden, abgelegt werden.
Der Garbage Collector ist ein Programmteil im Hintergrund des eigentlichen Programms, das gelegentlich nicht mehr erreichbare Instanzen aus dem Heap wieder frei und damit für andere Objekt zur Verfügung stellt.
ok Beispiel:
Test objekt = null;
Test objekt2 = null;
Test objekt = new Test();
objekt = objekt2;
jetzt wäre ja objekt wie du sagst nicht mehr zugreifbar weil die Referenz ja eine andere ist stimmts und es liegt aber immer noch im Speicher und verbraucht dort platz stimmts? also wäre 1 Objekt im Heap in meinem Beispiel????
Die Variable objekt zeigt noch auf das Objekt, welches mit new Test() angelegt wurde.
Wenn der Scope der Variablen verlassen wird, gibt es die Variable nicht mehr, die auf das Objekt zeigt, jedoch noch das Objekt. Diese Objekte räumt der Garbage Collektor gelegentlich weg.
Wenn die Variable aber in main() ist oder in einer vorhandenen Instanz einer Klasse definiert ist oder gar static ist, so gibt es die Variable noch und die Instanz von Test wird nicht gelöscht.
aha ok.... danke ): aber so richtig sicher bin ich mir noch nicht ):
und was ist das da eigentlich im Foto wo der ein neues Objekt erzeugt indem er mit einem Objekt eine Methode aufruft also
A z = x.f(y);
da wird ja dann bloß das x Objekt verändert stimmts ???
Entschuldige bitte die Verzögerung. Ich musste die letzte Sonne zum Joggen ausnutzen.
Nein, es wird für die Instanz von A, auf die die Variable x zeigt, die Methode f() aufgerufen. In der Methode f() wird mit this.a und this.b auf die Werte diese Instanz gesehen, auf die x zeigt.
Eine Variablendeklaration A z; ist eigentlich ein Zeiger auf ein Objekt vom Typ A, oder = null, wenn der Zeiger auf nichts zeigt.
Zeiger können sehr einfach kopiert werden.
Die Statements w = z; und z = y; kopieren nur die Zeiger und nicht die Objekte hinter den Zeigern. Man sieht es nur nicht, man muss es wissen.
Auf ein Objekt können 0 .... n Variablen zeigen.
A x = new A(1);
A y = x;
Damit gibt es ein Objekt, auf das sowohl x als auch y zeigen. Wenn du nun x = null; oder x = new A(2) setzt, so zeigt x auf nichts beziehungsweise ein neues Objekt. y zeigt weiterhin auf das Objekt, das x zuerst zugewiesen wurde. Es gibt nun nur noch einen Zeiger, der auf das Objjekt zeigt.
Wenn es dann keinen Zeiger / Variable mehr auf ein bestimmtes Objekt gibt, wird es irgendwann abgeräumt.
ok also bei A z = x.f(y) kommt dann a = 22, b = 21 raus oder?
ok ich hab die aufgaben nun gemacht kannst du kontrollieren ob das richtig ist ich gebe dann auch den Stern, also:
Bei Nummer 1: Es sind 18 Objekte nach Ablauf der Schleife Garbage
Bei Nummer 2: Nach dem Aufruf gibt es bloß 1 nicht Garbage Objekt
Bei Nummer 3: gar keine
Bei Nummer 4: Höchste Anzahl an nicht Garage Objekten ist 3
Bei Nummer 5: 2
Wenn du mit new ein Objekt, also eine Instanz einer Klasse, erzeugst, dann wird dieses in einem Speicherbereich namens Heap angelegt. new liefert die Adresse dieses Objekts (eine sogenannte Referenz) zurück, diese kannst du dann in deiner Variablen speichern und damit im Programm auf das Objekt zugreifen.
Wenn du nun beispielsweise einer solchen Variablen irgendwann eine Referenz auf ein anderes Objekt zuweist, dann wird die alte Referenz überschrieben. Soferne du diese nicht auch anderswo gespeichert hast, kannst du auf das Objekt nun nicht mehr zugreifen (du kennst ja seine Speicheradresse nicht mehr), es liegt aber immer noch im Speicher und verbraucht dort Platz.
Aus diesem Grund gibt es den Garbage Collector, der von Zeit zu Zeit solche nicht mehr referenzierten Objekte aus dem Speicher (also dem Heap) löscht und somit den von ihnen belegten Platz wieder freigibt.
Das ist eine deutliche Erleichterung für den Programmierer. In so mancher anderen Sprache (z.B. in C) muss sich nämlich der Programmierer darum kümmern, dass jeder von ihm angeforderte Speicherbereich nach der Benutzung auch wieder freigegeben wird. Sowas vergisst man gerne, und dann entsteht ein "memory leak" - d.h. das Programm belegt immer mehr Speicher, und irgendwann ist der voll …
ok Beispiel:
Test objekt = null;
Test objekt2 = null;
Test objekt = new Test();
objekt = objekt2;
jetzt wäre ja objekt wie du sagst nicht mehr zugreifbar weil die Referenz ja eine andere ist stimmts und es liegt aber immer noch im Speicher und verbraucht dort platz stimmts? also wäre 1 Objekt im Heap in meinem Beispiel????
ok ich hab die aufgaben nun gemacht kannst du kontrollieren ob das richtig ist ich gebe dann auch den Stern, also:
Bei Nummer 1: Es sind 18 Objekte nach Ablauf der Schleife Garbage
Bei Nummer 2: Nach dem Aufruf gibt es bloß 1 nicht Garage Objekt
Bei Nummer 3: gar keine
Bei Nummer 4: Höchste Anzahl an nicht Garage Objekten ist 3
Bei Nummer 5: 2
Heap ist der Haufen (die Halde) und bezeichnet einen Speicherabschnitt.
Garbage-Collector ist der Müllsammler und was macht der wohl, er räumt die Müllhalde (Heap) auf.
ok Beispiel:
Test objekt = null;
Test objekt2 = null;
Test objekt = new Test();
objekt = objekt2;
jetzt wäre ja objekt wie du sagst nicht mehr zugreifbar weil die Referenz ja eine andere ist stimmts und es liegt aber immer noch im Speicher und verbraucht dort platz stimmts? also wäre 1 Objekt im Heap in meinem Beispiel????
Genau. Du hättest ein Objekt Test, auf welches am Ende keine Referenz (Variable) mehr verweist. Dieses liegt im Heap und wäre erst später, wenn der GC einmal laufen würde (was er aber laut Aufgabenstellung nie tut), auf der Abschussliste.
oke also im grunde muss man bei der aufgabe bloß zählen wie viele Objekte erzeugt wurden ist das richtig? ob da Referenzen vertauscht wurden ist völlig egal? Hauptsache die Objekte zählen die mit new erzeugt wurden???