Vererbung

[pindakaas]

Tach Leute ich hab hier eine Aufgabe deren Lösung für mich einfach keinen Sinn macht

wir haben zwei Klassen eine mit ein Paar einfachen Methoden und eine zum Testen.
der Trick ist jetzt das Verständnis der Ausgabe die lautet A B L B X M wenn ich den code richtig gecopypastet hab.

Ich weiß nur nicht wieso ich kann ja mal schritt für schritt schreiben was ich erwarten würde.
Hier die Klassen

public class Oben {
public void gg (Oben o) { System.out.print("A "); }
public void gg (Mitte m) { System.out.print("B "); }
}
public class Mitte extends Oben {
public void gg (Oben o) { System.out.print("L "); }
public void gg (Unten u) { System.out.print("M "); }
}
public class Unten extends Mitte {
public void gg (Oben o) { System.out.print("X "); }
public void gg (Mitte m) { System.out.print("Z "); }
}

public class Prog {
public static void test() {
Oben oo = new Oben();
Oben ff = new Mitte();
Unten uu = new Unten();
oo.gg(ff);
oo.gg(uu);
ff.gg(ff);
ff.gg(uu);
uu.gg(ff);
uu.gg(uu);
}
}

Von oo.gg(ff) würde ich erwarten das B gedruckt wird da ff ja von der klasse Mitte ist
aber gut das heißt wohl, der Typ wird von der höchsten Vaterklasse genommen.
also: A
dann oo.gg(uu) wieder irritierend denn uu ist ja sozusagen Unten -> Mitte ->Oben aber okay
vielleicht ist der Typ immer die nächste Vaterklasse.
AB
dann ff.gg(ff) okay ff ist Mitte->Oben also:
ABL soweit sogut
dann ff.gg(uu) uu ist Unten ->Mitte->Oben also
ABLB denn ff hat ja die gg(Mitte) methode von oo
dann uu.gg(ff) ff ist Mitte->Oben uu hat eine eigene gg(Oben) methode also
ABLBX
dann uu.gg(uu) uu ist Unten->Mitte->Oben wird also als Mitte angesehen oder?
aber das stimmt nicht hier wird plötzlich die von ff geerbte Methode gg(Unten) verwendet
obwohl beim ersten Buchstaben die eigentlich klasse ignoriert wurde und statt dessen die Vater klasse
als Typ gesehen wurde wird hier der eigentliche Typ als Typ angesehen,
kann mir jemand den Unterschied erklären?
(die Pfeile -> sollen heißen Sohn->Vater ich kann mir nie merken wie rum die sein müssen)
Ich wäre für Hilfe sehr dankbar denn trotz ausgiebiger Suche in allen Richtungen kann ich mir das einfach nicht klar machen.
cheers pindakaas

 

[Landei]

Welche Methode aufgerufen wird, hängt vom statischen (Compilezeit-) Typ ab, nicht vom Laufzeittyp: Wenn du eine Variable hast, die als "Oben" deklariert ist, und der Compiler sich für irgendeine überladene Methode entscheiden muss, nimmt er die, die ein "Oben" erwartet, selbst wenn zur Laufzeit in der Variable ein "Unten" drinsteckt. Wie soll er es auch anders machen, im Bytecode muss ein definitiver Aufruf drinne stehen, nicht "nimm dir dir richtige Methode". Vielleicht wird das hier klarer:

Oben x = null;

if(Math.random() > 0.5) {
   x = new Mitte();
} else {
   x = new Unten();
}

//Jetzt KANN der Compiler den "richtigen" (Laufzeit-) Typ von x nicht wissen
//muss sich aber jetzt schon für eine Methode entscheiden:

new Oben().gg(x);

Deshalb kann der Compiler nur den statischen Typ von x berücksichtigen, ruft also die Oben-Variante auf. Eine Technik, um dieses Verhalten zu "korrigieren", ist Double Dispatch: Abhi On Java: Double dispatch in Java

 

[pindakaas]

okay danke soweit, dann ist ff vom Typ Oben soweit so gut
aber warum ist im vierten aufruf ff.gg(uu); uu als mitte gewertet
obwohl es doch als unten erstellt wurde ?

 

[SlaterB]

aus EXAKT denselben Grund?? es gibt nur zwei Methoden zur Auswahl, Parameter Oben oder Mitte, Mitte passt am besten

edit: ok, nur nahezu exakt, diesmal ist nicht nur unbekannt, von welchem Typ der Parameter ist,
sondern auch der Typ des aufgerufenden Objektes ff,
zur Compilierzeit ist nur das Interface Oben als Info vorhanden, egal welche Klasse es zur Laufzeit tatsächlich ist,
also muss davon eine der Methoden-Signaturen von Oben gewählt werden,

mit exakt derselben Signatur kann eine Methode in Subklassen zwar überschrieben werden,
nicht aber mit Überladung (andere besser passende Parameter)

 

[pindakaas]

Ich merke ich gerade ich komme hier ins schwimmen, zu Compilierungszeit steht doch schon
fest, dass uu vom Typ Unten ist und es steht auch fest, dass ff.gg drei methoden hat
je eine für oben mitte und unten wie kommt es, dass also unten hier als Mitte angenommen wird?

Ich muss jedoch zugeben, dass ich auch nicht genau weiß was der Compiler als gegeben annimmt und
was er als" das kann ich nicht wissen" ansieht.

Ich weiß wie anstrengend es ist jemandem im Internet sowas zu erklären daher wäre ich auch schon
über links die einen gut zu verstehenden Text dazu enthalten dankbar, ich weiß nicht mal wie
man das nennt, bei Vererbung scheint nichts dazu zu finden zu sein.

Wie immer danke für eure Zeit und Mühe.

 

[Landei]

Ja in deinem Fall wäre es zur Compilezeit noch leicht nachzuvollziehen, aber schau dir mein Beispiel mit random an, da geht das eben nicht mehr. Prinzipiell ist es für den Compiler nicht möglich, nachzuvollziehen, wo genau ein bestimmter Wert herkommt (kann ja auch aus einer Bibliothek sein, oder ein Objekt, dass über RMI gesendet wird u.s.w.) - deshalb versucht er es auch erst gar nicht.

 

[SlaterB]

etwas spät:

> dass ich auch nicht genau weiß was der Compiler als gegeben annimmt und was er als" das kann ich nicht wissen" ansieht

> wäre ich auch schon über links die einen gut zu verstehenden Text dazu enthalten dankbar

Landei hat in seinem Post doch ziemlich genau das aufgegriffen, schau dir nochmal sein Beispiel mit dem Zufall an,
an der Stelle wäre es für den Compiler unmöglich zu wissen, welches Objekt dran kommt,
selbst wenn er sich beim Kompilieren allzu viele Gedanken machen würde,

aber da überschätzt du ihn schon, die Variable ff ist vom Typ Oben, also ist Oben die relevante Klassen, deren Methoden stehen zur Auswahl,
fertig,

was der Compiler höchstens macht, ist, mehr oder weniger intelligent nachzuverfolgen, ob eine (lokale) Variable zum Zeitpunkt von Aufrufen null IST oder SEIN KANN, um dann entsprechende Fehlermeldungen oder Warnungen auszugeben, je nach Einstellungen

das von dir angedachte Verhalten fände ich persönlich nichtmal nützlich, sondern gefährlich,
auch wenn jetzt schon in der Java-Sprache ähnliche Probleme vorhanden sind, siehe
Diagnosing Java Code: The Broken Dispatch bug pattern

 

[Sonecc]

Anders gesagt:
ff wurde als Mitte erzeugt, ist aber vom Typ Oben.

ff hat daher 2 Methoden:

public void gg (Oben o)
public void gg (Mitte m)

Da ff als Mitte deklariert wurde wird die Methode die Oben als Parameter erwartet überschrieben.
Das bedeutet, dort kommt das "L" als Ergebnis.

ff kennt aber keine Methode die ein Parameter vom Typ Unten erwartet (da ff vom Typ Oben ist), deshalb wird die Methode aufgerufen, die als Parameter den Typ Mitte hat, wenn man ff.gg(uu) aufruft

 

[pindakaas]

HA!:toll: natürlich ff ist nicht von Typ mitte auch nicht von den methoden die es hat her jetzt versteh ich das ^^ die Aufgabe ist aber auch die volle Ladung. ff.gg(ff) spuckt L aus weil instanz methoden überschrieben werden in diesem Fall also gg(Oben) aus Mitte verwendet wird Obwohl ff vom Typ oben ist.
Bei ff.gg(uu) wird kein M sondern ein B gedruckt weil das Eine instanz von Oben ist .
dann x weil ff nicht Mitte sonder Oben ist
und dass M weil Unten diese Methode von Mitte erbt.

Danke danke danke ^^ ich hab solange über diesen scheiß nachgedacht das ich wie ich sehe das eigentliche Problem übersehen hab.

MFG pindakaas