ListIterator

[JavaStud45]

Hallo,

Ich lerne gerade für eine Prüfung und habe ne kurze Frage zum ListIterator.
Erstmal 2 Beispiele:

Bsp1:

ListIterator iterator = komponenten.listIterator();
while(iterator.hasNext())
{
    Komponente komponente = (Komponente)iterator.next();
    maut += komponente.getMaut();
}

getMaut() liefert einen Wert zurück (double)

Bsp2:

ListIterator iterator = componentList.listIterator();
while (iterator.hasNext())
{
    ((Component)iterator.next()).evaluate();
}

evaluate() liefert keinen Wert zurück, also führt nur was aus.

Sowohl komponenten, als auch componentList sind eine "LinkedList".


So nun zu den Fragen:

1) Warum steht beim Aufruf iterator.next() immer vornedran in Klammern der Rückgabewert? Muss das immer so sein?
Wenn ich andere Methoden aufrufe die einen Rückgabewert haben, muss ich das ja auch nicht machen.

2) Warum muss ich beim Bsp1 einen neuen Objektverweis anlegen, während ich beim Bsp2 ohne diese Deklaration auskomme und den vom iterator erhaltenen Wert direkt weiterverwenden kann? Liegt das daran, dass ich beim Bsp1 durch das getMaut() einen Wert zurückerhalte, oder an der Variable maut?
Oder kann ich beim Bsp1 anstelle der 2 Zeilen auch sowas machen:

maut += ((Komponente)iterator.next()).getMaut();

Ich versuche nun schon ziemlich lange dem auf den Grund zu gehen und finde dazu nichts, wenn mir da einer helfen könnte, wäre ich sehr dankbar.

 

[foobar]

Warum steht beim Aufruf iterator.next() immer vornedran in Klammern der Rückgabewert? Muss das immer so sein?

Das nennt man casten. Hat aber nichts mit Dieter Bohlen zu tun ;-) Benutz mal die Suchfunktion.

Oder kann ich beim Bsp1 anstelle der 2 Zeilen auch sowas machen:

Na klar, aber warum probierst du es nicht einfach selber aus.

Warum muss ich beim Bsp1 einen neuen Objektverweis anlegen, während ich beim Bsp2 ohne diese Deklaration auskomme und den vom iterator erhaltenen Wert direkt weiterverwenden kann?

Du mußt den Wert nicht in einer Varibalen zwischen speichern, nur manchmal ist das eben übersichtlicher.

 

[JavaStud45]

Vielen Dank schonmal für die Antwort,

Hab jetzt mal nach diesem typecast geschaut und rausgefunden, dass es zur typ umwandlung gebraucht wird und bei objekten zur "weiterentwicklung", d.h. in ein Objekt zu konvertieren, das in der Vererbungshirarchie weiter unten liegt.

Bei meinen Beispielen sind die eingetragenen typecasts jeweils die abstrakte Grundklasse. Das Ziel ist ja, von dem jeweiligen Objekt seine eigene "konkrete" Methode aufzurufen. Warum wird das nun dadurch erreicht, dass ich die jeweiligen Objekte auf die abstrakte Grundklasse "konvertiere". Wenn ich das typecast weglassen würde, und die Objekte Typ ihrer jeweiligen Klasse bleiben würden, dann wäre doch sichergestellt, dass auch seine Methode aufgerufen wird. Aber das geht ja so nicht.

Lange rede kurzer Sinn: Ich finde es unlogisch, würde es aber dennoch einfach mal bestätigt haben, dass ich in so einem Fall immer so vorgehen muss.

 

[SlaterB]

Was der Iterator zurückliefert, ist nicht die letztendliche Klasse,
die weiß der Iterator ja gar nicht, sondern die oberste aller Klassen: Object.

Insofert wird also schon 'weiterentwickelt' vom allgemein Objekt zur aus einem bestimmen Blickwinkel sehr spezifischen Komponent-Klasse.

Übrigens ist es gar nicht möglich, dass eine Operation mehrere Rückgabetypen hat.
Es kann immer nur einer sein, bei so einer grundlegend Operation wie iterator.next() logischerweise Object.

Wenn irgendeine Unterklasse von Komponent käme, wäre der Cast tatsächlich sinnlos und würde von einem schlauen Compiler sicherlich entfernt und vielleicht sogar als 'Unnecessary code' bemängelt. (testen..)

 

[JavaStud45]

Achso, ich glaub jetzt hab ich es langsam verstanden. Das kommt wohl davon, wenn man eine Programmiersprache nur theoretisch lernt.

Also dadurch, dass der Iterator ein "Universalinstrument" ist, bekomme ich durch den Befehl "iterator.next()" nur dann einen Objektverweis, mit dem ich z.b. eine Methode dieses Objekts aufrufen könnte, wenn ich den erhaltenen Objektverweis des allgemeinen Typs der "Mutterklasse" Object zum spezifischen Objektverweis (in den beiden Fällen einfach die abstrakte Grundklasse) umwandle, mit Hilfe eben diesem Typecast.

Mein Denkfehler war also die ganze Zeit, dass ich dachte, der Befehl "iterator.next()" liefert mir mein Objektverweis schon in eben dieser Form meiner Grundklasse. Der Iterator tut also auf Grund der "Universalität" alles als Objekt der "Mutterklasse" Object behandeln.

Hoffe es nun richtig verstanden zu haben und danke nochmal für die Hilfe, die mir Licht ins Dunkel brachte