override - overload - reintroduce - virtual

[cn-tools]

Hi @ all!

Könnte mir bitte jemand auf die Sprünge helfen bzw. sagen ob das überhaupt funktioniert?

Delphi-Quellcode:

TModelKlasseA = class(TObject)
end;
TModelKlasseB = class(TModelKlasseA)
end;

TKlasseA = class(TObjec)
  function GetMD: TModelKlasseA; virtual; abstract;
end;

TKlasseB = class(TKlasseA)
  function GetMD: TModelKlasseB; ????????
end;

Was muss ich bei TKlasseB.GetMD hinten angeben dass Delphi das richtig macht?
Das Programm soll, wenn TKlasseA.GetMD aufgerufen wird, die Methode TKlasseB.GetMD aufrufen.

thx@all4help
DANKE

lg aus Österreich

[himitsu]

virtual und dynamic besagen, daß diese Methode in Nachfahren überschreibbar ist

override sagt, daß diese Methode eine virtuelle/dynamische Methode eines Vorfahren überschreiben soll

abstract besagt, daß diese virtuelle/dynamische Mathode in der "ausgangsklasse" zwar deklariert, aber nicht implementiert ist.

overload besagt, daß es eine gleichnamige Methode gibt (natürlich mit anderen Parametern)
und diese paralell/alternativ aufrufbar sind

mit reintroduce sagt man, daß es in den Vorfahren eine gleichnamige Methode gibt,
man diese aber "absichtlich" verdecken will. (ohne reintroduce würde der Compiler eine entsprechende Warnung anzeigen



Lösung deines Problems: override
[edit] stümmt , also reintroduce und ohne virtual


[add]
http://www.delphi-treff.de/object-pa...akte-methoden/

[schlecki]

Zitat von himitsu:

Lösung deines Problems: override

Nicht ganz, da sich der Rückgabetyp der Funktion geändert hat. Richtig wäre hier reintroduce, welches besagt, dass sich die Signatur der überschriebenen Methode verändert hat (wobei der Rückgabetyp eigentlich nicht zur Signatur gehört)

[himitsu]

Stimm, hast Recht.

OK, Aufrufsignatur gehört der nicht, aber zur Gesamten schon.

Delphi-Quellcode:

TModelKlasseA = class(TObject)
end;
TModelKlasseB = class(TModelKlasseA)
end;

TKlasseA = class(TObjec)
  function GetMD: TModelKlasseA; 
end;

TKlasseB = class(TKlasseA)
  function GetMD: TModelKlasseB; reintroduce;
end;

function TKlasseA.GetMD: TModelKlasseA;
begin
  result := TModelKlasseA.Create;
end;

function TKlasseB.GetMD: TModelKlasseB;
begin
  result := TModelKlasseB.Create;
end;

Ich würde es dennoch mit Override lösen,
wobei hier TKlasseB dennoch TModelKlasseB ausliefen kann, da diese ja von TModelKlasseA abgeleitet ist.

Delphi-Quellcode:

TModelKlasseA = class(TObject)
end;
TModelKlasseB = class(TModelKlasseA)
end;

TKlasseA = class(TObjec)
  function GetMD: TModelKlasseA; virtual; abstract;
end;

TKlasseB = class(TKlasseA)
  function GetMD: TModelKlasseA; override;
end;

// TKlasseA.GetMD ist nicht implementiert

function TKlasseB.GetMD: TModelKlasseA;
begin
  result := TModelKlasseB.Create;
end;

Delphi-Quellcode:

TModelKlasseA = class(TObject)
end;
TModelKlasseB = class(TModelKlasseA)
end;

TKlasseA = class(TObjec)
  function GetMD: TModelKlasseA; virtual;
end;

TKlasseB = class(TKlasseA)
  function GetMD: TModelKlasseA; override;
end;

function TKlasseA.GetMD: TModelKlasseA;
begin
  result := TModelKlasseA.Create;
end;

function TKlasseB.GetMD: TModelKlasseA;
begin
  result := TModelKlasseB.Create;
end;

[mleyen]

Zitat von cn-tools:

Das Programm soll, wenn TKlasseA.GetMD aufgerufen wird, die Methode TKlasseB.GetMD aufrufen.

Ich glaube du meintest es andersrum:
Das Programm soll, wenn TKlasseB.GetMD aufgerufen wird, die Methode TKlasseA.GetMD aufrufen.
Ansonsten müsstest du nochmal TKlasseB in TKlasseA instanziieren, solange TKlasseB von TKlasseA abgeleitet ist.

[cn-tools]

Danke erstmal @ all für die schnellen Antworten ... bin gerade am abarbeiten eurer Vorschläge

@mleyen:
ich meinte eigentlich wenn in der Klasse "TKlasseA" die Methode "GetMD " aufgerufen wird.
Somit soll das Programm - weil in TKlasseA ist die Mehtode ja ABSTRACT - die Methode von TKlasseB aufrufen.

[himitsu]

Zitat von cn-tools:

ich meinte eigentlich wenn in der Klasse "TKlasseA" die Methode "GetMD " aufgerufen wird.
Somit soll das Programm - weil in TKlasseA ist die Mehtode ja ABSTRACT - die Methode von TKlasseB aufrufen.

Dann mußt es natürlich virtual/dynamic + override sein, aber bei sowas darf sich die Signatur nicht ändern.

[Hansa]

Es fehlt ein Stichwort : inherited; Ich würde es so programmieren :

Delphi-Quellcode:

TKlasseA = class(TObject)
  function GetMD: TModelKlasseA; virtual; // überschreibbar machen
end;

TKlasseB = class(TKlasseA)
  function GetMD: TModelKlasseB; override; // Vorgänger wird überschrieben
end;
..
function TKlasseA.GetMD: TModelKlasseA;
begin
// vorerst mal leer, kann/wird sich aber ändern. Nötig, weil abstract fehlt. 
// wird abstract gewünscht, dann besser die function für TKlasseA wegen Überflüssigkeit
// gleich weglassen und erst in TKlasseB einführen. Ausnahme : es handelt sich um eine Komponentenklasse,
// die verkauft werden soll etc.
end;

function TKlasseB.GetMD: TModelKlasseB;
begin
  inherited; // zuerst GetMD von TKlasseA ausführen. Wird das weggelassen, dann wird TKlasseA.GetMD NICHT ausgeführt
// der Krempel, den TKlasseB zusätzlich zu TKlasseA noch braucht
end;

Also nochmals im Klartext : auf abstract verzichten und lieber leere Methode einbauen, die sofort eingesetzt werden kann, selbst wenn sie anfangs nichts macht. Macht mans anders, dann ist die Gefahr ziemlich hoch, sich dauernd "abstracte" Compiler-Fehlermeldungen einzufangen.

[mkinzler]

Oder man macht es richtig! Den die Verwendung von abstrakten Methoden macht Sinn. Bei neueren Delphiversionen kann man zudem mit strikt abstrakte Methoden nehmen ( Fehler nicht erst zur Laufzeit bei Zugriff)

[himitsu]

Zitat von mkinzler:

Oder man macht es richtig! Den die Verwendung von abstrakten Methoden macht Sinn. Bei neueren Delphiversionen kann man zudem mit strikt abstrakte Methoden nehmen ( Fehler nicht erst zur Laufzeit bei Zugriff)

Selbst die älteren Compiler geben aber zumindestens Warnungen aus.

Und wie mkinzler schon richtig sagte, sind abstrakte Methoden nicht zu verachten, jedenfalls wenn sie in Basis-Klassen liegen, welche selber niemals direkt instantiirt werden ... die quasi nur eine gemeinsame Schnittelle definieren, wie z.B. TStrings.
Vorteil hierbei ist nämlich, daß der Compiler sich dann meldet, wenn man was in der Ableitung vergißt zu implementieren.
(bei den leeren Methoden würde man sich frühestens zur Laufzeit wunden, wenn irgendwas aus unerklärlichen Gründen nicht so läuft, wie gewollt)