Klasse ableiten: Methode überschreiben & Rückgabetyp ändern

[changlee]

Hallo,

so langsam muss ich mich auch mal mit Vererbung und Polymorphie auseinandersetzen. Leider habe ich ein Problem mit dem Überschreiben einer Funktion.

Ich habe folgende Vorfahrklassen:

Delphi-Quellcode:

  TJob = class(Tobject)
  private
    fId: integer; // eindeutige JobId
  public
    Feedback: integer;
    property Id: integer read fId;
    constructor Create(aParent: TJobList);
    destructor Destroy; override;
  end;

  TJobList = class(TObject)
  private
    fJobs: TList;
  public
    function  NewJob: TJob; virtual;  // virtual = darf in abgeleiteten Klassen überschrieben werden
    constructor Create;
    destructor  Destroy; override;
  end;

Diese möchte ich nun folgendermaßen ableiten:

Delphi-Quellcode:

  TBackupData = record
    Name: string;
    //...
  end;

  TBackupJob = class(TJob)
  private
    fBackupData: TBackupData;
  public
    property BackupData:TBackupData read fBackupData;
    procedure Setup;
  end;


  TBackupList = class(TJobList)
  private
    //..
  public
    function  NewJob: TBackupJob; override;  // Compiler Fehler: Deklaration von NewJob unterscheidet sich von vorheriger Deklaration
  end;

Überall wo dann in der JobList auf die einzelnen Jobs zugegriffen wird, steht TJob(fJobs[i]).MachWas. Das sollte ja eigentlich kein Problem darstellen, wenn fJobs[i] in diesem Fall kein TJob sondern ein davon abgeleiteter TBackupJob ist, oder?


Wie muss ich es denn machen, um den im Quelltext erwähnten Compilerfehler nicht zu bekommen?

Viele Grüße,
changlee.

[mkinzler]

Zitat:

Das sollte ja eigentlich kein Problem darstellen, wenn fJobs[i] in diesem Fall kein TJob sondern ein davon abgeleiteter TBackupJob ist, oder?

Nein den ein Backupjob ist ja ein Job
(TBackupJob IS-A TJob)
Wenn du beim Ableiten einer Methode deren Signatur änderst, ist das kein Überschreiben (override) sondern Überladen (overload)

[webcss]

Du solltest in der Basisklasse die funktion ohne virtual definieren

Delphi-Quellcode:

...
function  NewJob: TJob; 
...

in der abgeleiteten Klasse definierst du NewJob einfach neu

Delphi-Quellcode:

...
function  NewJob: TBackupJob;
...

und implementierst sie so

Delphi-Quellcode:

function  NewJob: TBackupJob;
begin
  Result:= TBackupJob(inherited add);
end;

[changlee]

Danke für die Antworten.

Ich habe jetzt das "vitual" in der Basisklasse weggelassen und NewJob überschrieben.


Aber folgendes verstehe ich nicht ganz:

Zitat:

Zitat von webcss

und implementierst sie so

Delphi-Quellcode:

function  NewJob: TBackupJob;
begin
  Result:= TBackupJob(inherited add);
end;

inherited ruft ja in diesem Fall das NewJob der Basisklasse auf und liefert ein TJob zurück. TBackupJob(inherited) würde ich ja verstehen, aber was hat es mit dem "add" auf sich?


//Edit:

hab gerade gemerkt, dass Delphi das "add" auch gar nicht kennt.
Meintest du vielleicht:

Delphi-Quellcode:

function  TBackupList.NewJob: TBackupJob;
begin
  result := TBackupJob(inherited NewJob);  
end;

[webcss]

Zitat:

Zitat von changlee

hab gerade gemerkt, dass Delphi das "add" auch gar nicht kennt.
Meintest du vielleicht:

Delphi-Quellcode:

function  TBackupList.NewJob: TBackupJob;
begin
  result := TBackupJob(inherited NewJob);  
end;

Ja, sorry, genauso meinte ich das. Die Gewohnheit... :drunken:
Alternativ kannst Du auch ne generische Liste nehmen, wo der Compiler dann den Typ einflickt.
So sparst Du Dir viel Tipparbeit und TypeCast Fehler.
Geht aber erst ab/mit D9 bzw. FPC 2.4.0.

[hoika]

Hallo,

warum benutzt du nicht reintroduce ?

Delphi-Quellcode:

type
  TClass1 = class
    function GetValue: Integer; virtual;
  end;

  TClass2 = class(TClass1)
    function GetValue: Boolean; reintroduce;
  end;

function TClass1.GetValue: Integer;
begin
  Result:= 1;
end;

function TClass2.GetValue: Boolean;
begin
  Result:= True;
end;

Heiko

[changlee]

was wäre denn der Unterschied / Vorteil von reintroduce gegnüber einem direkten Überschreiben?
Ehrlich gesagt verstehe ich auch nicht den Sinn der Direktive virtual.
Ich dachte virtual sei nötig, wenn eine Nachfahrklasse die Methode überschreiben dürfen soll. Offenbar geht es ja aber auch ohne virtual. :gruebel:

[guinnes]

Zitat:

Zitat von changlee

Offenbar geht es ja aber auch ohne virtual. :gruebel:

Du hast damit die Methode nicht überschrieben, du hast nur eine Methode eingeführt, die genau so heisst.
Überschriebene Methoden stehen in der Virtuelen Methoden Tabelle, womit es möglich ist, immer die zum Objekttyp passende Methode aufzurufen :

Delphi-Quellcode:

Type
  Klasse1 : Class
    Meth1( Bla : Integer);
  end;

  Klasse2 : Class(Klasse1)
    Meth1 ( Bla : Integer);
  end;

  Procedure TuWas( Obj : Klasse1);
  Begin
    Obj.Meth1(42);
  end;

  Procedure Test;
  begin
    TuWas(InstanzVonKlasse1);// Tut, wie es tuen soll
    TuWas(InstanzVonKlasse2);// Tut nicht, es wird die Methode Meth1 von Klasse1 !! Ausgeführt
  end;

Bei Vererbung :

Delphi-Quellcode:

Type
  Klasse1 : Class
    Meth1( Bla : Integer);Virtual;
  end;

  Klasse2 : Class(Klasse1)
    Meth1 ( Bla : Integer);Override;
  end;

  Procedure TuWas( Obj : Klasse1);
  Begin
    Obj.Meth1(42);
  end;

  Procedure Test;
  begin
    TuWas(InstanzVonKlasse1);// Tut, wie es tuen soll
    TuWas(InstanzVonKlasse2);// Tut wie es tuen soll;
  end;

[hoika]

Hallo,

in #1 stand
Compiler Fehler: Deklaration von NewJob unterscheidet sich von vorheriger Deklaration

Ich wollte zeigen, wie man den Umgehen kann.


Heiko

[sx2008]

Du solltest deine Klassen so designen, dass der unterschiedliche Rückgabetyp überhaupt nicht notwendig wird.
TBackupJob hat ein weiteres Property aber das sollte doch keine Rolle spielen.
Die Klasse TJobList dient gleichzeitig hier als abstract Factory.
Aber anscheinend sind die erzeugten Objekte noch nicht vollständig initialisiert und nur aus diesem Grund brauchst du den konkreten Typ.

Eigentlich macht es auch keinen Sinn eine Ableitung von TJobList zu erstellen, denn es gibt keinen Grund,
weshalb nicht ganz unterschiedliche Job-Objekte in einer Liste geführt werden dürfen.

[changlee]

Genial, es funktioniert. Wirklich vielen Dank für die Antworten.
Das was Guinnes geschrieben hat, kannte ich so gar nicht. Ich dachte, wenn ich

Delphi-Quellcode:

TJob(InstanzVonTBackupJob).Free

aufrufe, würde immer das Destroy von TJob aufgerufen werden.

sx2008 hat recht, da sich der pointer, den ich mit TJob(..) verarbiete tatsächlich bewust ist, dass er in wirklichkeit ein TBackupJob ist, brauche ich die TJobList überhaupt nicht abzuleiten :-D

Dann sieht es bei mir jetzt so aus:

Delphi-Quellcode:

  TBackupJob = class(TJob)
  private
    fBackupData: TBackupData;
    //..
  public
    property BackupData:TBackupData read fBackupData write fBackupData;
    constructor Create(aParent: TJobList);
    destructor Destroy; override;
  end;

implementation

constructor TBackupJob.Create(aParent: TJobList);
begin
  inherited Create(aParent);
  fBackupData.Name := 'Neue Backup Aufgabe';
end;


destructor TBackupJob.Destroy;
begin
  showmessage('BackupDestroy');
  inherited;
end;

und aufrufen kann ich es dann mit:

Delphi-Quellcode:

procedure TForm1.NewTaskButtonClick(Sender: TObject);
var aList: TJobList;
    aJob: TBackupJob;
    bd: TBackupData;
begin
  test := TJobList.Create;
  try
    aJob := TBackupJob.Create(aList);
    bd := aJob.BackupData;   //aJob.BackupData.Name := 'test'; <-- ging leider nicht..
    bd.Name := 'test';
    aJob.BackupData := bd;
    showmessage(aJob.BackupData.Name);
  finally
    test.Free;
  end;
end;

Es wird auch tatsächlich das destroy von TBackupjob ausgeführt!
Die funktion TJobList.NewJob habe ich einfach entfernt. Muss man es eben mit Create selbst machen.

Nochmal Danke! Jetzt wird das alles viel sauberer (und kürzer).

PS: Guinnes, kennst du auch so ein tolles Beispiel für die Bedeutung von reintroduce gegenüber virtual/override und Überladen?

[xZise]

Also soweit ich weiß blendet reintroduce nur die Warnung aus, arbeitet aber so, als würde dort weder virtual noch override stehen.
Übrigens das „Instanz von Klasse1“ oder so ist nicht gaaaanz so einfach ;)

Delphi-Quellcode:

type
  TClass1 = class
    function random : string;
  end;
  TClass2 = class(TClass1)
    function random : string;
  end;

var
  c : TClass1;
begin
  c := TClass2.Create;
  ShowMessage(c.random); // Hier wird random von TClass1 aufgerufen
end;

Mit virtual/override, würde dann random von TClass2 aufgerufen werden.

MfG
Fabian