Klassen Feste und veränderbare Typen in Hierarchien

[Dasha]

Hi,

Ich komme momentan bei einen Projekt nicht weiter:
(Ich darf keine Instanzvariablen benutzen nur Methoden und Rückgabewerte)
Nicht über die dummen Werte und den Sinn wundern, ich hab es nur vereinfacht es geht mir ums Prinzip!

Klasse Auto erbt von Klasse Fahrzeug:
Fahrzeug hat die Methode:

 public int preis()
   {
       return 1;
   }

Das ist ein Standartpreis.
Den Preis für alle Fahrzeuge, die keinen eigenen Preis haben, wird in dieser Methode festgelegt.



Die Klasse Auto hat auch die "selbe" methode aber der Preis ist anders.
Das war meine Idee, aber die Methode überschreibt ja nicht die Methode der Superklasse. Also wird immer nur die Methode int preis() von der Superklasse benutzt.

 public int preis()
   {
       return 20;
   }

Die Klasse Fahrzeug rechnet dann mit dem Preis.
Ich kann aber keine Parameter bei der Methode benutzen weil ich überall wo mit den Preis gerechnet wird "public int preis(Wert)" schreiben müsste.
Aber da ich keinen Parameter habe, kann ich auch nicht von der Unterklasse "Auto" den Preis mit "super.preis(Wert)" ändern.

Hat jemand Lösungsvorschläge?
-Keine Instanzvariablen
-Der Preis darf nur an einer Stelle vorkommen und soll dort auch geändert werden können.
-Der Preis muss für alle Fahrzeuge, muss in der Klasse "Fahrzeuge" änderbar sein und für die Klasse "Auto" muss ich den Preis in der Klasse "Auto" ändern können.

Wenn ich ein Objekt Auto erstelle muss ich von dort auf die Methode der Superklasse zugreifen können und den Wert dort ändern, überschreiben oder übergehen.
Aber wie gesagt ich kann keine Parameter benutzen, weil sonst der Parameter Preis mehrfach im Code auftauchen würde.

mfg

 

[pro2]

Das war meine Idee, aber die Methode überschreibt ja nicht die Methode der Superklasse. Also wird immer nur die Methode int preis() von der Superklasse benutzt.

Normal sollte die Methode überschrieben werden..

 

[Gast2]

Das war meine Idee, aber die Methode überschreibt ja nicht die Methode der Superklasse. Also wird immer nur die Methode int preis() von der Superklasse benutzt.

Doch, genau das macht sie. Wenn du preis() auf ne Instanz der Unterklasse aufrufst bekommst du den geänderten Preis, in deinem Fall also 20.

Die Klasse Fahrzeug rechnet dann mit dem Preis.
Ich kann aber keine Parameter bei der Methode benutzen weil ich überall wo mit den Preis gerechnet wird "public int preis(Wert)" schreiben müsste.
Aber da ich keinen Parameter habe, kann ich auch nicht von der Unterklasse "Auto" den Preis mit "super.preis(Wert)" ändern.

Erklär das mal bitte etwas genau, eventuell auch mit ein bissl Code, ich hab keine Ahnung was du da willst.

 

[Dasha]

Stimmt, ihr habt recht es wird wirklich überschrieben
Ich hab vermutlich irgendwas beim Testen vergessen oder irgendwas falsch eingegeben.

Aber warum es genau überschrieben wird ist mir noch etwas unklar, deswegen dachte ich auch es geht nicht so wie ich es gemacht habe.
Wenn ich eine Methode in der Hierarchie aufrufe wird ja von unten nach oben getestet ob diese Methode existiert. In meinen Fall wird erst bei der Unterklasse geschaut und dort wird die Methode

public int preis()
   {
       return 20;
   }

gefunden.

So jetzt existiert aber in der Superklasse auch die Methode + die Rechnung:

public int preis()
   {
       return 20;

}

public int preisMalPreis()
{
return preis() *preis();
}

Wie darf ich mir das überschreiben genau vorstellen?
Beim Compilen geht er durch und macht aus den ganzen Klassen in der Vererbungsstruktur eine ganze Klasse, puzzelt alles zusammen?
Also überschreiben heißt: "Wenn ich die Superklasse die Methode "preis()" hat können die ganzen Superklassen auch die Methoden haben aber die werden gar nicht berücksichtigt.

mfg

 

[bygones]

compiler != runtime...

der compiler puzzelt da keine klassen zusammen.... es gibt fuer jede klasse ein eigenes .class file

ueberschreiben heisst einfach dass du eine methode mit der selben Signatur in einer Unterklasse definiert. Wenn du dann eine Instanz der Unterklasse hast wird dort die methode genommen. Ist dort keine definiert, wird in der/den Superklasse(n) geschaut.

 

[Gregorrr]

Ja, genau. Die Entscheidung, welche Methode aufgerufen wird, wird erst zur Laufzeit bestimmt. Denn das ist abhängig von dem Objekt, welches gerade der Variablen zu einem bestimmten Zeitpunkt zugewiesen wird - was sich ja auch ändern kann.

Dass aber eine bestimmte Methode überhaupt ausgeführt werden kann wird schon zur Kompilierungszeit durch den Typ bestimmt. Somit ist sichergestellt, dass es eine Implementierung dieser Methode gibt.

Das fasst man im großen und ganzen übrigens zum Begriff Polymorphismus zusammen.