Polymorphie

[Kiimarii]

Hey ich habe ein Problem , und zwar weiß ich nicht warum in dem folgendem Code nur "M" ausgegeben wird:

class All { /* ....*/ }
class Most extends All { /*......*/}
class Special extends Most { /*......*/}


class Top {
    public void m(All p)
    {
        System.out.println("A ");
    }
}

class Middle extends Top {

    public void m(All p)
    {
        System.out.println("M ");
    }
    public void m(Special p)
    {
        System.out.println("L ");
    }
}

class Bottom extends Middle {

    public void m(Most p)
    {
        System.out.println("V ");
    }
    public void m(Special p)
    {
        System.out.println("X ");
    }
}


class Test {
   public static void run()
   {
   All all = new All();
   Most most = new Most();
   Special special = new Special();

   Top x = new Middle();
   Top y = new Bottom();
   Middle z = new Bottom();

   x.m(most);
   x.m(special);
   y.m(all);
   y.m(special);
   z.m(all);
   z.m(most);
      }
}

Kann mir einer schritt für schritte erklären warum nur "M" ausgegeben wird? Danke!

 

[Whatever20073]

Also ich bin auch absoluter Anfänger und das wird mein erster Post hier im Forum aber ich beschäftige mich auch gerade mit Polymorphie in java und ich würde das so beurteilen (zur besseren Übersicht einfach mal als Java Kommentar):

x.m(most); // Methode m wurde überschrieben in Middle -> dynamisch gebunden an die Methode von Middle -> M
x.m(special); // beim kompilieren wird nur der statische Typ berücksichtigt (x = Top) also wird die Methode m(All p) in Bytecode geschrieben (geht weil special ist ein all). m(Special p) aus Middle überschreibt nicht m(All p) aus Top also Dynamische auflösung an m(All p) von Middle -> M
y.m(all); // Bottom hat keine eigene Methode für 'all' also wird die vererbte Methode von Middle gerufen (die m(All p) von Top überschreibt) -> M
y.m(special); // gleiche Prinzip wie bei x.m(special);
z.m(all); // gleiche prinzip wie y.m(all);
z.m(most); // wieder das gleiche statisch aufgelöst zu m(All p) von Middle. Keine dynamische Bindung an m(Most p) aus Bottom weil nichts überschrieben wird

Aber bestimmt wird es hier welche geben die mehr Ahnung davon haben und es entweder bestätigen oder als völligen Unsinn erklären können

 

[Kiimarii]

Was meinst du mit dynamisch gebunden , statische auflösung etc. Kenne diese Begriffe nicht wirklich.

mfg Kiimarii

 

[Whatever20073]

dann wird es etwas mühsam.. dann solltest du dich vielleicht erstmal etwas mehr mit Polymorphie beschäftigen?! Gibt es einen Grund warum du dich dann gleich mit diesem Code auseinandersetzt?

 

[Kiimarii]

Naja bin nicht wirklich ein "Anfänger" kann sehr vieles und verstehe auch wirklich alles ( Lambda, funktionale Interfaces, anonyme Klassen, binaryTrees und was es nicht alles gibt) aber diese Sache stört mich irgendwie, es ist als ob mein Gehirn es einfach nicht richtig verstehen möchte.

 

[Flown]

Auweia das ist ein wenig ein komplexeres Thema, aber hier tritt kein einziges mal dynamic dispatching (dynamische Bindung) auf. Zum Nachlesen in der JLS - wird "Anfänger" nicht helfen: HIER

Hier geht es um die Sichtbarkeit der Methoden: Die Variablen x, y sind vom Typ Top. Dieser beinhaltet nur die Methode (All)void (Notation ist: (Parametertype)Returntype). Darum kann auf ((Top) x) nur die eine Methode aufgerufen werden, da für x,y nur dieser Typ garantiert ist (statische Typ).

Bei der Variable z siehts so aus, dass der statische Typ Middle ist und du nur Methoden aufrufst, die keine (Special)void aufruft. Würdest du noch z.m(special); hinzufügen, würde auch ein 'X' erscheinen. Da zur runtime immer der spezifischste Typ gewählt wird. Da most aber kein Special ist, wird hier die Methode (All)void aufgerufen.

Ich hoffe das bringt etwas Licht in die Sache.

 

[mrBrown]

Die Methode aus Top wird in Middle überschrieben, deshalb greift da trotzdem dynamisches Binden. der statische Typ ist la Top, der dynamische aber nicht.