Rückgabewert von Kontruktoren

[chillerStudent]

Hallo,

ich habe eine Liste erstellt und möchte int Zahlen einfügen:

public class Knoten {
 
 private int key;
 private Knoten next;

 Knoten(int key) {
  this.key=key;
 }

 Knoten(int key, Knoten next) {
  this.key=key;
  this.next=next;
 }

}

public class List {

 Knoten head = null;
 public void insert(Knoten k) {
  head.setNext( new Knoten(k, head,getNext())); //Fehler: k wird als int Wert erwartet.
 }

}

public class Test {
 public static void main(String[] args) {
  List liste = new List();
  liste.insert(new Knoten(3)); //Parameter von insert soll nicht verändert werden!!
 }
}

Soweit ich weiß, gibt es keinen Rückgabewert eines Konstruktors. Wie kann ich dann trotzdem einen Kontruktor als Parameter nutzen?

 

[javampir]

hi,
wo ist denn dein problem?

insert(new Knoten(3))

müsste doch wunderbar funktionieren?
javampir

 

[chillerStudent]

Das Problem ist, dass er bei der Implementierung von der Methode insert beim ersten Parameter ein int wert erwartet. Also hier:

public void insert(Knoten k) { // k ist vom Typ Knoten
head.setNext( new Knoten(k, head.getNext())); // dieses k soll aber int sein

Wie geht das?

 

[kaoZ]

indem du eine in der Klasse Knoten eine Methode anbietest die als Rückgabewert eine int zurückliefert, Konstruktoren haben keine Rückgabewerte!

Methoden hingegen haben immer einen Rückgabewert, auch wenn dieser void , also nichts ist .

class Knoten{


public int getValue(){
   return 13;
}

}

Fiktives Beispiel , nicht auf deinen Code bezogen !

dies liefert bei folgendem Aufruf z.B einen Wert des primitiven datentyps int

liste.insert(new Knoten().getValue()); // new Knoten().getValue() liefert in diesem Fall 13 (int)

/* und ist somit equivalent zu */

liste.insert(13);

 

[chillerStudent]

Gute Idee kaoZ, aber wie schaffe ich es mit

insert(new Knoten(3))

??

 

[Harry Kane]

Gute Idee kaoZ, aber wie schaffe ich es mit

insert(new Knoten(3))

??

Was willst du denn "schaffen"? Was ist das Ziel deiner Insert-Methode? Ich vermute, entweder soll header zum next des übergeben Knotens gemacht werden oder umgekehrt:

public class List {
    Knoten head = null;
    public void insert(Knoten k) {
        head.setNext(k);
        // oder vielleicht k.setNext(header);
    }
}

Vorher solltest du head aber noch initialiseren.
Wenn du nur einen int zur Verfügung hast, ist es unerheblich, on du aus dem int vor dem Aufruf von insert einen Knoten machst oder im Methodenrumpf. Letzteres sähe dann so aus:

public class List {
    Knoten head = null;
    public void insert(int i) {
        Knoten k = new Knoten(i);
        head.setNext(k);
        // oder vielleicht k.setNext(header);
    }
}

 

[Thallius]

indem du eine in der Klasse Knoten eine Methode anbietest die als Rückgabewert eine int zurückliefert, Konstruktoren haben keine Rückgabewerte!

Würde ich so nicht sagen. Konstruktoren liefern halt nur immer einen Zeiger auf die "konstruierte" Instanz zurück.

Gruß

Claus

 

[kaoZ]

Würde ich so nicht sagen. Konstruktoren liefern halt nur immer einen Zeiger auf die "konstruierte" Instanz zurück.

Konstruktoren erstellen Objekte/Instanzen von Klassen, Variablen welche für diese angelegt werden ( in diesem Fall k ) verweisen/referenzieren auf das Objekt und dessen stelle im Speicher / Heap, inJava gibt es keine 'Zeiger' im eigentlichen Sinne wie man es aus C kennt.

Der 'Zeiger' wäre also in diesen Fall die Referenz, und nicht das erstellte Objekt selbst.

Knoten k = new Knoten(); 
/* k referenziert nun das erstellte Objekt und verweist somit auf die Stelle an der dieses Objekt erstellt wurde (Heap) */

Nichts des so trotz besitzt ein Konstruktor keinen in Java definierten Rückgabewert!

Wie nun aber Harry Kane schon geschrieben hatte ist nun die Frage, was genau du mit der insert Methoden bezwecken möchtest, und wozu du dieser außer des Knotens selbst auch noch den im Konstruktor definierten integer der Klasse Knoten übergeben möchtest.

Wenn du dadurch festlegen möchtest an welcher stelle deiner Liste sich der Knoten am ende befinden soll, versteh ich nicht so ganz was der key deiner Knotenobjekte damit zu tun haben soll

 

[Thallius]

Konstruktoren erstellen Objekte/Instanzen von Klassen, Variablen welche für diese angelegt werden ( in diesem Fall k ) verweisen/referenzieren auf das Objekt und dessen stelle im Speicher / Heap, inJava gibt es keine 'Zeiger' im eigentlichen Sinne wie man es aus C kennt.

Der 'Zeiger' wäre also in diesen Fall die Referenz, und nicht das erstellte Objekt selbst.

Auch wenn man den Zeiger in Java Referenz nennt, so bleibt er doch einfach nur ein Zeiger auf einen allozierten Speicherbereich der mit Daten gefüllt ist.

Gruß

Claus

 

[kaoZ]

Richtig.

Letzten endes sollte dem TO nur klar sein das es sich nicht um das eigentliche Objekt handelt mit welchem er Arbeitet, sondern lediglich mit einer Referenz also einem Verweis auf den Seicherbereich (im Heap) welcher das Objekt enthält, bzw. wo dieses abgelegt worden ist.

Nennen kann man die Referenz letztlich wie man will, egal ob Zeiger, Verweis, Referenz oder oder oder.

 

[chillerStudent]

Ich möchte mit der Methode einen Knoten am Ende der Liste hinzufügen:

        Knoten head=null;
        Knoten tail=null;
	public void insert(Knoten k) {

		k=new Knoten(k.getKey());
		if(head==null) {
		        head=k;
		} else {
			tail.setNext(k); // Warum bekomme ich hier NullP.Ex. ? 
		} tail=k;

 

[stg]

Nunja, zu Beginn ist

tail

nunmal

null

. Das musst du beim Einfügen auch berücksichtigen...

 

[chillerStudent]

Ist das hier richtig?

        Knoten head=null;
        Knoten tail=null;
        public void insert(Knoten k) {
            tail = k;
            k=new Knoten(k.getKey());
            if(head==null) {
                    head=k;
            } else {
                tail.setNext(k); 
            } tail=k;

Wenn ich nacheinander die Methode aufrufe, dann bekomme ich nicht das ganze Ergebnis:

Knoten list = new Knoten();
list.insert(new Knoten(4));
list.insert(new Knoten(1));
list.insert(new Knoten(5));

Ergebnis:
1
4

Ich möchte:
5
1
4

 

[stg]

Ich würde vorschlagen, du malst dir einfach mal eine Skizze für die verschiedenen Fälle (Liste leer und Liste nicht leer), anhand derer du dir überlegst, wie du die "Zeiger" auf

head

und

tail

jeweils setzen musst.

 

[chillerStudent]

mhhh... wie kann ich denn auf den letzten Knoten zugreifen, damit ich tail darauf zuweisen kann?

 

[stg]

Du hast in deiner Liste doch sowohl einen Verweis auf

head

, als auch einen auf

tail

gespeichert. Von der Namensgebung her gehe ich davon aus, dass der eine der erste und der andere der letzte besetze Knoten in der Liste sein soll...?!
Wenn du in eine leere Liste einfügst, dann sind beide natürlich zunächst

null

. Nach dem Einfügen ist dann genau ein Knoten in der Liste, also sollte in

head

und in

tail

jeweils der selbe Knoten gespeichert sein, nur, wenn mehr als ein Knoten in der Liste ist, dann sind

head

und

tail

wirklich verschieden.
Wie gesagt, mal dir mal eine Skizze, damit es direkt vor Augen siehst, wann du welchen Zeiger umbiegen musst und welchen nicht. Deine bisherigen Versuche sehen für mich mehr danach aus, dass du einfach versuchst richtig zu raten...