Syntax in Java?
Beispielcode:
public class Element {
private int wert;
private Element weiter;
public Element(int i) {
wert = i;
weiter = null;
}
public void Einfügen(int neuerWert) {
Element lauf = this;
while (lauf.weiter != null) {
lauf = lauf.weiter;
}
lauf.weiter = new Element(neuerWert);
}
}
Ich verstehe Ausdrücke wie z.B. "lauf.weiter" nicht.
Was bedeutet das genau? Ich habe also eine Referenzvariable der Klasse "Element". Dieser Variable wurde das aktuelle Objekt durch this zugewiesen.
"weiter" ist wieder eine Referenzvariable. Aber was genau macht der Ausdruck "lauf.weiter"?
3 Antworten
Der Ausdruck `lauf.weiter` greift auf das Feld `weiter` des Objekts `lauf` zu. Hierbei ist `lauf` eine Referenz auf ein Objekt der Klasse `Element`, und `weiter` ist eine Referenz auf das nächste `Element` in einer verketteten Liste. Mit `lauf.weiter` kannst du also auf das nächste Element in der Liste zugreifen oder es verändern.
Ich denke, am einfachsten ist es zu verstehen, wenn man es sich einmal grafisch skizziert.
Angenommen also, du hast eine solche Liste:
----------- ----------- -----------
| Element | | Element | | Element |
|---------- ----------- -----------
| weiter -------->| weiter ------->| weiter --------> null
| wert: 1 | | wert: 2 | | wert: 3 |
----------- ----------- -----------
Jedes Element hat einen Wert und ein Feld weiter, welches auf das nachfolgende Element zeigt.
Wenn du nun ein neues Element an diese Liste anhängen möchtest, musst du ausgehend von dem Element, auf welches du Zugriff hast, erst einmal schauen, dass du an das Ende der Liste kommst.
Du nimmst dir also das aktuelle Element und referenzierst mit einer neuen Variable darauf:
Element lauf = this;
Dann schaust du, ob dieses Element einen Nachfolger hat:
while (lauf.weiter != null) {
Wenn dem so ist, merkst du dir diesen Nachfolger:
lauf = lauf.weiter;
und schaust erneut, ob dieser wiederum einen Nachfolger hat. Dieser Prozess wiederholt sich durch die Schleife so lange, bis du auf ein Element in dieser Liste triffst, welches keinen Nachfolger hat (bzw. wo weiter auf null referenziert). Du kannst in diesem Fall davon ausgehen, am Ende der Liste angekommen zu sein.
Anschließend kann ein neues Element (mit dem neuen Wert) erstellt und als neuer Nachfolger des bisherig letzten Elements gesetzt werden.
Du kannst dir den Ablauf ebenso mit einem Debugger anschauen. Angenommen, wir starten bei dem Element mit dem Wert 1 und wollen ein Element mit dem Wert 4 anhängen. Dann hättest du diese Zwischenergebnisse:
Element lauf = this; // lauf = Element(wert:1)
while (lauf.weiter != null) { // true
lauf = lauf.weiter; // lauf = Element(wert:2)
while (lauf.weiter != null) { // true
lauf = lauf.weiter; // lauf = Element(wert:3)
while (lauf.weiter != null) { // false
lauf.weiter = new Element(4); // weiter = Element(wert:4)
Ich würde dir empfehlen, wo nur möglich Skizzen zu zeichnen, an denen man sich Probleme/Zustände visuell besser verdeutlichen kann. Nach meiner Erfahrung hilft es jedenfalls vielen Personen, das Problem so fassbarer zu machen. Gerade bei Datenstrukturen (Bäumen, Listen, u.ä.) lohnt es sich, wenn man beispielsweise Einfüge-, Sortier- oder Suchoperationen implementieren möchte.
Einige Algorithmen (z.B. Sortierverfahren) werden des Weiteren in Wikipedia ausführlich mitsamt grafischen Animationen, Detailbeschreibungen und Pseudocodes vorgestellt.
lauf.weiter
Dürfte der Zugriff auf die Variable weiter des Objekts lauf sein.
Danke sehr! Ich habe das momentan in Algorithmen & Datenstrukturen. Macht mir ordentlich zu schaffen.