Klasse im Array speichern -> Fehlermeldung

[hotkey]

Vielen Dank für die Antworten.

Ich weiß , dass das nicht sooo OOP ist.

Aber das was mir vorgeschlagen wird , mit Überschreiben abstract , virtual etc.

Das KENNE ich doch garnicht ?

Das haben wir im Unterricht noch nie behandelt , ich kann ja nix anwenden , was ich noch nicht hatte.

Klar , ich kanns raufklatschen und dann compilieren , kein Ding , aber ich will ja nachvollziehen und verstehen , was da gemacht wird.

Versteht ihr ?

[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)

[Sir Rufo]

Aber er hat das mit dem abstract und virtual ja noch nicht gehabt.

Allerdings frage ich mich, wie der Lehrer dann auf die Idee kommt, so eine Aufgabe zu stellen - vor dem Hintergrund OOP.

Entweder der TE hat da etwas verpasst oder der Lehrer verpennt

[himitsu]

Theoretisch sollten die Leehrer auch erstmal das Debugging und die Codeformatierung beibringen.
(so als Zweites/Drittes, nach den Syntaxgrundlagen)