Klasse im Array speichern -> Fehlermeldung

[himitsu]

Hier ist eine "Basis"-Klasse, welche eine überschreibbare Methode enthält:

Delphi-Quellcode:

type
  TVorfahr = class
    procedure MachWas;
    procedure MachNochwas; virtual;
  end;

procedure TVorfahr.MachWas;
begin
  ShowMessage('ich bin MachWas von TVorfahr');
end;

procedure TVorfahr.MachNochwas;
begin
  ShowMessage('ich bin MachNochwas von TVorfahr');
end;

Wenn der Vorfahr noch keine Implementation dieser Methode benötigt, dann kann man sie abstact deklatieren.
(es befindet sich dann "noch" kein Code in dieser Methode)

Delphi-Quellcode:

type
  TVorfahr2 = class
    procedure MachWas;
    procedure MachNochwas; virtual; abstract;
  end;

procedure TVorfahr2.MachWas;
begin
  ShowMessage('ich bin MachWas von TVorfahr2');
end;

Ein Nachfahr kann nun diese Methode mit neuem Code überschreiben.

Delphi-Quellcode:

type
  TNachfahr = class(TVorfahr)
    procedure MachNochwas; override;
  end;

procedure TNachfahr.MachNochwas;
begin
  ShowMessage('ich bin MachNochwas von TNachfahr');
end;

Oder diese Methode wird ergänzt/erweitert, indem der Code des Vorfahren mit aufgerufen (inherited) wird.

Delphi-Quellcode:

type
  TAndererNachfahr = class(TVorfahr)
    procedure MachNochwas; override;
  end;

procedure TNachfahr.MachNochwas;
begin
  inherited;
  ShowMessage('ich bin MachNochwas von TNachfahr');
end;

Jenachdem welche Klasse nun erstellt wurde, kann man über die selbe Schnittstelle (hier die von TVorfahr) irgendeine Methode aufrufen, welche von einem Nachfahren überschrieben wurde.

Delphi-Quellcode:

var
  X: TVorfahr;

ShowMessage('jetzt kommt TVorfahr');
X := TVorfahr.Create;
try
  X.MachWas;
  X.MachNochwas;
finally
  X.Free;
end;

ShowMessage('jetzt kommt TNachfahr');
X := TNachfahr.Create;
try
  X.MachWas;
  X.MachNochwas;
finally
  X.Free;
end;

ShowMessage('jetzt kommt TAndererNachfahr');
X := TAndererNachfahr.Create;
try
  X.MachWas;
  X.MachNochwas;
finally
  X.Free;
end;

ShowMessage('jetzt ist Schluß');

Dem Code ist es also egal, ob und welcher Nachfahre verwentet wurde, da alle wichtigen Schnittstellen schon im Vorfahren existiert, welche man nun problemlos aufrufen kann.
Hier der Beweis:

Delphi-Quellcode:

var
  X: TVorfahr;
  i: Integer;

for i := 0 to 2 do begin
  case i of
    0: begin
      ShowMessage('jetzt kommt TVorfahr');
      X := TVorfahr.Create;
    end;
    1: begin
      ShowMessage('jetzt kommt TNachfahr');
      X := TNachfahr.Create;
    end;
    2: begin
      ShowMessage('jetzt kommt TAndererNachfahr');
      X := TAndererNachfahr.Create;
    end;
  end;
  try
    X.MachWas;
    X.MachNochwas;
  finally
    X.Free;
  end;
end;
ShowMessage('jetzt ist Schluß');

(statt der MessageBox, könnte man den Text auch in ein Memo schreiben)