Hallo. Ich habe versucht, eine verkettete Liste zu programmieren. Leider funktioniert das Einfügen eines neuen Elements scheinbar nicht. Es wäre schön zu erfahren, woran das liegen könnte. Wenn ich die Anzahl der Elemente meiner Liste ausgebe, wird mir eine "0" angezeigt, obwohl ich in meinem Hauptprogramm drei Elemente an die Liste angefügt habe. Ich wäre sehr dankbar, wenn mir jemand zeigen kann, wo der Fehler liegt!
Code:
package linkedList;
public class Main {
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
linkedList.insert("Hallo");
linkedList.insert("Test");
linkedList.insert("Wie gehts?");
System.out.println(linkedList.getNumberOfElements());
}
}
Code:
package linkedList;
public class LinkedList<T> {
private Node<T> startNode;
public LinkedList() {
startNode = null;
}
private Node<T> getNullNode() {
Node<T> currentNode = this.startNode;
while (currentNode != null) {
currentNode = currentNode.getNextNode();
System.out.print("Durchlauf ");
}
return currentNode;
}
public void insert(T object) {
Node<T> nullNode = getNullNode();
System.out.println(getNullNode());
nullNode = new Node<T>();
nullNode.setObject(object);
}
public int getNumberOfElements() {
int numberOfElements = 0;
Node<T> currentNode = startNode;
while (currentNode != null) {
currentNode = currentNode.getNextNode();
numberOfElements++;
}
return numberOfElements;
}
}
Code:
package linkedList;
public class Node<T> {
private T object;
private Node<T> nextNode;
public Node() {
this.object = null;
this.nextNode = null;
}
public T getObject() {
return object;
}
public Node<T> getNextNode() {
return nextNode;
}
public void setNextNode(Node<T> nextNode) {
this.nextNode = nextNode;
}
public void setObject(T object) {
this.object = object;
}
}
Genau genommen kriege ich ja nicht "null", sondern eine Referenz, die auf eine Speicherstelle zeigt. Nur zeigt diese Speicherstelle eben auf null. Oder ist null nicht als Wert, der von einer Referenz geliefert wird, sondern als Adresse (bzw. Referenz) an sich zu verstehen?
Ich dachte, die Funktion liefert mir folgendes:
<Adresse (----> null)>
oder kriege ich in Wirklichkeit sowas wie unten hier?
<leere Adresse>
Kommt auf deine Definition von "Wert" an. Da Java ja bekanntlich für Argumente von Methodenparametern die Aufrufkonvention "Call-by-Value" besitzt, kann man schon sagen, dass eine Referenz auch ein Wert ist. Dass implementierungstechnisch dahinter eine Adresse steckt, bekommt man in Java tatsächlich niemals mit.
Ein Wert ist in meinen Augen das eigentliche Datum. Die Adresse ist sozusagen die Angabe des Ortes, an dem man das Datum finden kann. Ich weiß, strengenommen ist eine Adresse auch ein Wert, aber das würde jetzt zu kompliziert werden.
void funktion(Integer a) {
a = new Integer(55);
}
void caller() {
Integer x = new Integer(1);
funktion(x);
System.out.println(x.toString());
}
Frage: was wird bei Aufruf von caller() ausgegeben?
(EDIT: Antwort: 1)
Warum? x ist eine Referenz auf ein Integer-Objekt. Die Referenz wird by-value übergeben, d. h. funktion wird mit einer Kopie dieser Referenz aufgerufen. Die Zuweisung in funktion() ändert also höchstens die Kopie, nicht aber die ursprüngliche Referenz.
Die null-Referenz referenziert, wie Du richtig gesagt hast, "Nichts". In C ist NULL z. B. einfach ein Zeiger auf etwas, das keinen Typ besitzt und an Adresse 0 liegt.