Java Objekt-Return in einer For-Schleife

[Michi]

Hallo,
ich hatte vor kurzem einen Thread gestartet gehabt (http://forum.de.selfhtml.org/archiv/2009/2/t183085/#m1212252), in der ich den Java-code von unserem Professor nicht kapiert hatte.
Bin den Code Schritt für Schritt durchgegangen und habe es verstanden. An einer kleinen Stelle habe ich jedoch nur noch ein Problem. Dies wäre die folgende Stelle:

for (ListenElement frosch = anfang; frosch != null; frosch=frosch.getWeiter())

Mein Problem liegt hier: frosch=frosch.getWeiter()
Die Methode liefert das Listenelement weiter. Wahrscheinlich das erste gleich. Wie zählt er jedoch die ganzen Listenelemente durch. Nach meinem Verständnis würde er doch immer das gleiche weiter zurückgeben???

Grüße

[stareagle]

Moin,

for (ListenElement frosch = anfang; frosch != null; frosch=frosch.getWeiter())

Mein Problem liegt hier: frosch=frosch.getWeiter()
Die Methode liefert das Listenelement weiter. Wahrscheinlich das erste gleich. Wie zählt er jedoch die ganzen Listenelemente durch. Nach meinem Verständnis würde er doch immer das gleiche weiter zurückgeben???

Leider kann man über das Innenleben der Methode getWeiter() nur Vermutungen anstellen (oder habt ihr den Code auch zur Verfügung).  Das ganze sieht aber extrem nach verketteten Listen aus.

Jeder Aufruf wird das nächste Element liefern, und wenn kein weiteres Element mehr vorhanden ist, wird NULL geliefert.

Das ganze könnte eventuell wie folgt aussehen (ohne Anspruch auf Vollständigkeit):

  
public class ListenElement {  
  private Listenelement naechstesElement;  
  
  //... Eventuelle weitere Attribute  
  
  public void anfuegen(ListenElement element) {  
      // Hier sollte man prüfen ob naechtesElement noch leer ist, und  
      // falls nicht eine Exception werfen */  
  
    this.naechstesElement = element;  
  }  
  
  public ListenElement getWeiter() {  
    return this.naechstesElement  
  }  
}  

Ich hoffe das hilft dir.

Gruß

Stareagle

[Tim Tepaße]

Hallo,

for (ListenElement frosch = anfang; frosch != null; frosch=frosch.getWeiter())>

Dein Professor will Dir eine einfache einfach verkettete Liste beibringen. So eine Liste besteht aus einzelnen Elementen, hier als Objekte der Klasse ListenElement implementiert. Wenn man nur die Informationen anguckt, die in den Listen-Element-Objekten gespeichert sind, dann sind das zum einen eine Referenz auf die im ListenElement gespeicherten Daten und eine Referenz auf das in der Liste folgende Listenelement:

( daten | weiter )

„weiter“ zeigt nun auf ein weiteres Listenelement oder auf null, wenn Du am Ende angelangt bist. Die Liste [1, 2, 3] wird dann so repräsentiert:

( daten | weiter )
      ↓        ↓
      1        ( daten | weiter )
                   ↓        ↓
                   2        ( daten | weiter )
                                ↓        ↓
                                3       null

„Verkettet“ heisst diese Liste, weil ein Listenelement immer auf das nächste zeigt. In Deiner for-Schleife passiert nun folgendes:

• Die Variable „frosch“ zeigt am Anfang der Schleife, aber auch nur dort auf das erste Listenelement, das da „anfang“ heisst.
• Es wird im jedem Schleifendurchlauf getestet ob frosch gleich null ist, d.h. ob man schon am Ende ist.
• Wenn nicht, wird irgendwas im Schleifenrumpf gemacht.

• Jetzt kommt frosch=frosch.getWeiter() – die Variable frosch zeigt danach auf das Objekt, das das „weiter“ des erstens Objektes war. Also auf das zweite Listenelement. Die Variable frosch verändert sich also mit jedem Durchlauf der Schleife; schließlich ist sie variabel. Stell es Dir vor wie einen weitern Zeiger in meiner obigen ASCII-Art, der sich bewegt.

• Und irgendwann kommt wird dann dem „frosch“ die „null“ zugewiesen, weil im letzte Listenelement „weiter“ auf null zeigt. Konsequenterweise wird im darauf folgenden Schleifendurchlauf wieder darauf getestet, ob auf null gezeigt wird und dann die Schleife abgebrochen.

Es ist bei so etwas, gerade wenn man versucht es ganz am Anfang stehend zu lernen, wirklich oft hilfreich, sich die Strukturen aufzumalen und gedanklich durchzugehen. Gemalte Boxen und Pfeile mögen albern wirken, helfen aber. ;)

Tim

[Michi]

Hey, Tim und Stareagle,
vielen Dank für die ausführliche Hilfestellung.
Das mit der Verkettung habe ich nach langer Nachdenkerei und Aufzeichnerei hingekriegt und verstanden.

»» for (ListenElement frosch = anfang; frosch != null; frosch=frosch.getWeiter())>

• Jetzt kommt frosch=frosch.getWeiter() – die Variable frosch zeigt danach auf das Objekt, das das „weiter“ des erstens Objektes war. Also auf das zweite Listenelement. Die Variable frosch verändert sich also mit jedem Durchlauf der Schleife; schließlich ist sie variabel. Stell es Dir vor wie einen weitern Zeiger in meiner obigen ASCII-Art, der sich bewegt.

Das Problem lag nur hier beim letzten Teil der Schleife, der weiterzählen sollte.

  
        Liste l = new Liste();  
        l.fuegeEinAmAnfang(4);  
        l.fuegeEinAmAnfang(5);  
        l.fuegeEinAmAnfang(3);  
        l.fuegeEinAmEnde(8);  
        l.fuegeEinAmEnde(9);  
        l.fuegeEinAmAnfang(7)  

Die Liste würde praktisch so aussehen:
7 3 5 4 8 9

In der For-Schleife holt er nun im ersten Durchlauf den anfang, also 7. Dann holt er den "weiter" von 7, das wäre dann 3. Anschließend holt er weiter von 3, das wäre 5. Ah, ich habs jetzt denke ich gecheckt.

Ich hatte nämlich am Anfang vermutet, dass er immer die 7 holen müsste. Also nach dem Druchlauf er das weiter von der 7 holt.
Nachdem ich den Text hier verfasst habe, habe ich den Durchlauf kapiert.

Nochmals danke an alle :-)