Zitat von
grade in der Shoutbox:
NamenLozer, 22:19
@himitsu, 20:41: ich weiß, hab ich ja auch geschrieben. Ich versteh nur nicht, wieso das gleiche nicht bei Interfaces geht.
himitsu, 20:51
Und da Interfacemethoden standardmäßig über einen Index verwaltet werden, kann es da eh keine Mehrfachvererbung geben.
himitsu, 20:41
Du kannst aber mehrere Interfaces einem Objekt zuweisen.
Stevie, 19:53
Weil "keine Mehrfachvererbung" auch für Interfaces gilt? :p
NamenLozer, 14:37
Wieso kann eine Klasse mehrere Interfaces implementiren, aber ein Interface nicht von mehreren Interfaces abgeleitet sein?
Warum wird das wohl so ein
Normaler Weise werden die Methoden bei Interfaces über eine Art "einfache Liste mit Methodenzeigern" verwaltet.
Und bei der Interface-Vererbung werden einfach vom neuen Interface die Methoden hinten drangehängt.
Und genau deswegen kann/darf man nicht einfach Methoden weglassen oder in anderer Reihenvolge deklarieren, wenn man "Kopieen" eines Interfaces erstellt.
Delphi-Quellcode:
type
IMyIntfA = interface
procedure Aaa; {0}
procedure Bbb; {1}
procedure Cee; {2}
procedure Ddd; {3}
procedure Eee; {4}
procedure Fff; {5}
procedure Ggg; {6}
end;
IMyIntfB = interface
procedure Aaa; {0}
procedure Bbb; {1}
procedure Cee; {2}
procedure Eee; {3} // vertauscht
procedure Ddd; {4} //
procedure Fff; {5}
// hier fehlt was
end;
IMyIntfC = interface
procedure Hhh; {0}
procedure Iii; {1}
procedure Jjj; {2}
end;
IMyIntfD = interface(IMyIntfA)
procedure Hhh; {7}
procedure Iii; {8}
procedure Jjj; {9}
end;
IMyIntfX = interface(IMyIntfA, IMyIntfC)
// implizit über IMyIntfA enthalten
//procedure Aaa; {0}
//procedure Bbb; {1}
//procedure Cee; {2}
//procedure Ddd; {3}
//procedure Eee; {4}
//procedure Fff; {5}
//procedure Ggg; {6}
// implizit über IMyIntfC enthalten
//procedure Hhh; {0}
//procedure Iii; {1}
//procedure Jjj; {2}
// neue Methoden von IMyIntfX
procedure Kkk; {7}
procedure Lll; {8}
procedure Mmm; {9}
end;
// aber jetzt gäbe es mehrfach gleiche Indize,
// welches sich nicht adressieren ließen,
// denn was wäre denn nun z.B. eine 1?
// ok, also dann könnte Delphi theoretisch die Nummern "einfach" weiterzählen,
IMyIntfY = interface(IMyIntfA, IMyIntfC)
// implizit über IMyIntfA enthalten
//procedure Aaa; {0}
//procedure Bbb; {1}
//procedure Cee; {2}
//procedure Ddd; {3}
//procedure Eee; {4}
//procedure Fff; {5}
//procedure Ggg; {6}
// implizit über IMyIntfC enthalten
//procedure Hhh; {7}
//procedure Iii; {8}
//procedure Jjj; {9}
// neue Methoden von IMyIntfY
procedure Kkk; {10}
procedure Lll; {11}
procedure Mmm; {12}
end;
// aber NEIN, dann würden die Indize nicht mehr mit denen vom IMyIntfC übereinstimmen
IMyIntfA = das Ausgangsinterface
IMyIntfB = enthält eigentlich einige Methoden von IMyIntfA, außer daß etwas vertauscht ist.
Wenn man dieses also auf ein Interface vom Typ IMyIntfA anwendet, dann klappt daß, außer daß z.B. beim Aufruf von Eee intern das Ddd ausgeführt wird.
IMyIntfC und IMyIntfD = die sehen eigentlich gleich aus, sind es aber nicht
IMyIntfX und IMyIntfY = dieses geht zum Glück nicht, denn wie man sieht, stimmt da nix mehr.