Multimethoden

[EDIT]Abgetrennt von Sprachverwässerung[/EDIT]

Was sind Multimethoden?

Multimethoden sind Methoden die den gleichen Namen aber unterschiedliche Parameter haben, welche von einem gemeinsamen Basistyp abgeleitet wurden.

class Base
{...}

class Derived1 : Base
{...}

class Derived2 : Base
{...}

...
// Multimethoden

foo(Base c)
{...}

foo(Derived1 c)
{...}

foo(Derived2 c)
{...}

// Instanzierung
Base d0 = new Base();
Base d1 = new Derived1();
Base d2 = new Derived2();

// Aufruf ohne Multimethoden
foo(d0); // ruft foo(Base c) auf
foo(d1); // ruft foo(Base c) auf
foo(d2); // ruft foo(Base c) auf

// Aufruf mit Multimethoden
foo(d0); // ruft foo(Base c) auf
foo(d1); // ruft foo(Derived1 c) auf
foo(d2); // ruft foo(Derived2 c) auf

Multimethoden bestimmen also dynamisch welchen Typ die Methodensignatur hat und ruft dann passen die Methode auf. Damit kann man das Visitor Pattern stark vereinfachen.

Ganz doof gefragt, wieso geht das heute nicht schon?

Per Überlagerung?

Oder überseh ich da grad spontan was?

Hallo Der Eisbär,

ja, du übersiehst, dass es momentan nur mit dem statischen Typ geht und maxE sich das für den dynamischen Typ wünscht.

Dynamische Bindung funktioniert momentan nur für das Objekt, für das die Methode aufgerufen wird, aber nicht für die Parameter(-Objekte).

herbivore

Funktionsüberladung geht heute schon, hat aber erst mal nichts mit Multimethoden zu tun. Das besondere ist hier, dass d0, d1, d2 auf ihre Basisklasse geboxt wurden. Rufst du foo() auf, dann wird natürlich nur foo(Base c) aufgerufen. Bei Multimethoden wird aber zusätzlich der eigentliche Typ erkannt. D1 und d2 sind nämlich vom Typ Derived1 und Derived2 und werden bei Multimethoden automatisch (zur Laufzeit) an die richtige Methode delegiert.

Ah okay ... habs gesehen 🙂

hm, und wie würde ich das jetzige verhalten dann bei den mulitmethoden schaffen?

oder würde man dsa garnicht wollen?

Sehe ich das richtig, dass foo() "statisch", bzw. einfach als globale Funktion definiert ist? Dann wäre doch foo(d0) identisch mit dem OO-Pendant d0.Foo(). Wo ist nun der Vorteil?

Hier ist foo statisch. Man könnte natürlich foo zu einer Instanzmethode machen und dann die abstrakten Methoden aus der Basisklasse implementieren. Allerdings wird so etwas in bestimmten Softwarearchitekturen nicht unbedingt gern gesehen. Siehe Vistitor-Pattern. Die Idee ist hier, dass du Daten auf der einen Seite und Operationen auf der anderen Seite hast. Möchtest du eine neue Operation auf diese Daten definieren, dann schreibst du dir einfach einen neuen Visitor (Die Klassen, die deine Daten repräsentieren müssen nicht verändert werden). Eigentlich genau so, wie man es von einem gutem Softwareentwurf erwarten. Wenn du jetzt aber die foo-Methoden als Instanzmethoden definierst, dann hast du diese Trennung nicht mehr.
Schönes Beispiel zu diesem Thema und warum Multimethoden dieses Pattern so vereinfachen: http://nice.sourceforge.net/visitor.html