Beispiel für Polymorphie gesucht

[Luckie]

Ich arbeite gerade an einem Tutorial über Klassen in Delphi. Zum Thema Polymorphie habe ich mir folgendes Demo geschrieben:
Unit1:

Delphi-Quellcode:

uses
  Family;

procedure TForm1.btnParentsClick(Sender: TObject);
var
  Parents: TParent;
begin
  Parents := TParent.Create;
  try
    ShowMessage(Parents.GetType);
  finally
    FreeAndNil(Parents);
  end;
end;

procedure TForm1.btnSonClick(Sender: TObject);
var
  Son: TParent;
begin
  Son := TSon.Create;
  try
    ShowMessage(Son.GetType);
  finally
    FreeAndNil(Son);
  end;
end;

Und die Unit Family mit der Klasse:

Delphi-Quellcode:

unit Family;

interface

type
  TParent = class(TObject)
  public
    function GetType: String; virtual;  // zum Überschreiben markieren
  end;

type
  TSon = class(TParent)
  public
    function GetType: String; override;  // Eltern-Methode überschrieben
  end;

implementation

////////////////////////////////////////////////////////////////////////////////
//
//  TParent.GetType
//
//    Verwandtschaftsbeziehung.

function TParent.GetType: String;
begin
  result := 'Eltern';
end;

////////////////////////////////////////////////////////////////////////////////
//
//  TSon.GetType
//
//    Verwandtschaftsbeziehung.

function TSon.GetType: String;
begin
  result := 'Sohn';
end;

end.

Ich bin damit allerdings noch nicht so ganz glücklich. Hat eventuell jemand eine bessere Idee? Es sollte möglichst einfach und übersichtlich sein. Eventuell reicht es ja schon die Methoden besser zu benennen oder nur etwas zu ergänzen.

Es wäre auch schön, wenn man die Operatoren as und is einbauen könnte.

[Sanchez]

Ich würde deine beiden Klassen durch eine abstrakte Oberklasse erweitern:

Delphi-Quellcode:

unit Family;

interface

type
  TFamilyMember = class(TObject)
  public
    function GetType: String; virtual; abstract;  // muss Überschrieben werden
  end;

type
  TParent = class(TFamilyMember)
  public
    function GetType: String; override;  // FamilyMember-Methode überschrieben
  end;

type
  TSon = class(TFamilyMember)
  public
    function GetType: String; override;  // FamilyMember-Methode überschrieben
  end;

implementation

////////////////////////////////////////////////////////////////////////////////
//
//  TParent.GetType
//
//    Verwandtschaftsbeziehung.

function TParent.GetType: String;
begin
  result := 'Eltern';
end;

////////////////////////////////////////////////////////////////////////////////
//
//  TSon.GetType
//
//    Verwandtschaftsbeziehung.

function TSon.GetType: String;
begin
  result := 'Sohn';
end;

end.

Denn dein Beispiel würde ja bedeuten, dass der Sohn eine Art von Elternteil ist.

grüße, daniel

[choose]

Hallo Luckie,

schön, dass Du Dir die Mühe machen willst. Vielleicht kannst Du bei der Gelegenheit auch gleich den Begriff der abstrakten Klasse einführen? Oft wird die Eleganz von Lösungen dieser Art verkannt, obgleich mit ihnen etwas verwirrende Zuweisungen der Art

Delphi-Quellcode:

var
  myParent: TParent;
begin
  myParent:= TChild.Create;

vermieden werden können...

Ich dachte an eine Klassifizierungslösung (ala Aristoteles), also eine Form der Spezialisierung, wobei ich aus Vereinfachungsgründen die Spezialisierung selbst (zB in Form neuer Operationen) nur geringfügig (Im Fall der Zitrusfrucht) beachte:

Delphi-Quellcode:

type
  TFruit = class //pure abstract class
  public
    function GetTaste: string; virtual; abstract;
  end;

  TCitrusFruit = class(TFruit) //pure abstract class introduces new ops
  public
    procedure Squeeze; virtual; abstract;
  end;

  TLemon = class(TCitrusFruit)  // same taste as citrus fruit
  public
    function GetTaste: string; override;  // acerbic 
    procedure Squeeze; override;
  end;
    
  TGrapefruit(TCitrusFruit) = class
  public
    function GetTaste: string; override;  // disgustful ;)
    procedure Squeeze; override;
  end;
  
  TBanana(TFruit) = class
  public
    function GetTaste: string; override;  // sugary
  end;

Mit einer Hierarchie dieser Art ist die Verwendung etwas "natürlicher"

Delphi-Quellcode:

type
  myFruit: TFruit;
begin
  myFruit:= TBanana.Create;
  myFruit.GetTaste;

und lässt ebenfalls "natürliche" Casts etc zu

Delphi-Quellcode:

if myFruit is TCitrusFruit then
  with myFruit as TCitrusFruit do
    Squeeze;

Edit: Vorfahren der Klassen angegeben

[Luckie]

Dann wäre auch das Schlüsselwort abstract drin.

@Choose: Da mus sich jetzt erstmal durchsteigen. :-/

[Treffnix]

@ choose: Und das klappt so? Woher weiss Delphi denn, dass TLemon eine TCitrusfrucht ist?

[ot] Irgendwie hab ich jetzt Lust auf frischgepressten O-Saft [/ot]

[Luckie]

Fehler von Choose, da fehlt überall die Angabe des Parents.

[Treffnix]

Hab ich mir auch gedacht. Aber ich war am grübeln, ob er das vielleicht mit der Eleganz meinte. Bei choose weiss man ja nie...

[choose]

Zitat von Treffnix:

Bei choose weiss man ja nie...

Das denke ich mir auch manchmal

Habe tatsächlich in der Eile die Vorfahren vergessen, schön, dass das Beispiel trotzdem verstanden wurde!

[Luckie]

@Choose: was hast du denn jetzt genmacht?
TGrapefruit(TCitrusFruit) = class Was gibt denn das, wenn es fertig wird?

[Treffnix]

Zitat:

Was gibt denn das, wenn es fertig wird?

Obstalat?