Typumwandlung: Elemente der Unterklasse in Oberklasse

[enigma]

Hallo Delphi Community,

gestern habe ich ein Thema erstellt, das leider nicht ganz klar war – sorry! Aber vielen Dank für eure Tipps ��
Ich möchte in einem Objekt der Oberklasse auf die Attribute und Methoden der Unterklasse zugreifen.
Ausprobiert habe ich Typumwandlung, aber vielleicht habt ihr andere Ideen...

Kurzer Nachtrag: ich habe mehrere Unterklassen, die als Parameter für TOberklasse.Test(AObj: TOberklasse) verwendet werden können. Der Übersicht halber habe ich nur eine Unterklasse aufgeführt.

Aufruf der Methode Test in

Delphi-Quellcode:

lObjOberklasse.Test(lObjUnterklasse);

procedure TOberklasse.Test(AObj: TOberklasse);
var lObj: TOberklasse;
//var lObj: TUnterklasse;
begin
  lObj := TOberklasse.Create;
  if AObj is TUnterklasse then
    lObj := AObj as TUnterklasse;                                               //hier verwende ich Typumwandlung
  ShowMessage('lObj.ClassName = ' + lObj.ClassName);
  ShowMessage('lObj.Name = ' + lObj.Name);
  ShowMessage('lObj.Methode = ' + lObj.Methode);
end;

Oben stimmt für lObj der Klassenname „TUnterklasse“, aber „Name“ und „TestMethode“ sind für dieses gecastete lObj nicht deklariert.

Hier die Definition der beiden Klassen:

Delphi-Quellcode:

  TOberklasse = class(TObject)
    public
      procedure Test(AObj: TOberklasse);
      constructor Create;
  end;

  TUnterklasse = class(TOberklasse)
    public
      Name: String;
      function TestMethode: String;
      constructor Create;
  end;

[DeddyH]

Zitat:

Ich möchte in einem Objekt der Oberklasse auf die Attribute und Methoden der Unterklasse zugreifen.

Dann deklarier den Parameter doch gleich mit dem passenden Typen.

Delphi-Quellcode:

type
  TUnterklasse = class;  // Forward-Deklaration

  TOberklasse = class
  public
    procedure Test(AObj: TUnterklasse);
    constructor Create;
  end;

  TUnterklasse = class(TOberklasse)
  public
    Name: String;
    function TestMethode: String;
    constructor Create;
  end;

Ungetestet, sollte aber eigentlich funktionieren.

[enigma]

Vielen Dank,
aber das klappt leider nicht.

Kurzer Nachtrag: ich habe mehrere Unterklassen, die als Parameter für TOberklasse.Test(AObj: TOberklasse) verwendet werden können. Der Übersicht halber habe ich nur eine Unterklasse aufgeführt.

[DeddyH]

Bei mir klappt das ganz wunderbar.

Delphi-Quellcode:

type
  TUnterklasse = class; // Forward-Deklaration

  TOberklasse = class
  public
    procedure Test(AObj: TUnterklasse);
  end;

  TUnterklasse = class(TOberklasse)
  public
    function TestMethode: String;
  end;

{ TOberklasse }

procedure TOberklasse.Test(AObj: TUnterklasse);
begin
  if Assigned(AObj)  then
    ShowMessage(AObj.TestMethode);
end;

{ TUnterklasse }

function TUnterklasse.TestMethode: String;
begin
  Result := 'Wuppdi';
end;

...

procedure TForm5.Button1Click(Sender: TObject);
var
  lOberObj: TOberklasse;
  lUnterObj: TUnterklasse;
begin
  lUnterObj := nil;
  lOberObj := TOberklasse.Create;
  try
    lUnterObj := TUnterklasse.Create;
    lOberObj.Test(lUnterObj);
  finally
    lOberObj.Free;
    lUnterObj.Free;
  end;
end;

[himitsu]

Zitat:

AObj as TUnterklasse; //hier verwende ich Typumwandlung

Der interne Typ wird niemals umgewandelt, sondern nur die Variable ändert sich, aber drin bleibt, was drin war.

Zitat:

Delphi-Quellcode:

  lObj := TOberklasse.Create;
  if AObj is TUnterklasse then
    lObj := AObj as TUnterklasse; //hier verwende ich Typumwandlung

Ja, der Typ von AObj wird richtig zu Unterklasse (und es ist auch wirklich Unterklasse drin)
und beim Zuweisen an lObj wird wieder Oberklasse draus, weil die Variable ändert sich ja nicht (aber dennoch bleibt Unterklasse drin)

Die Variable lObj ist und bleibt immer Oberklasse und somit kann nur auf Dinge zugegriffen werden, welche Oberklasse kennt, egal ob Unterklasse drin sein mag.

Außerdem hat dieses Stück Code ein wunderschönes Speicherleck, da niemand das erstellte Oberklasse freigibt,
und nach überschreiben mit AObj auch nicht mehr freigeben kann, weil niemand mehr den Objektzeiger kennt.

Delphi-Quellcode:

procedure TOberklasse.Test(AObj: TOberklasse);
var 
  lObj: TUnterklasse;
begin
  ShowMessage('AObj.ClassName = ' + AObj.ClassName);
  if AObj is TUnterklasse then begin
    lObj := AObj as TUnterklasse;  // lObj := TUnterklasse(AObj); ... ob ein harter oder weicher Cast, ist egal, da IS es bereits geprüft hat
    ShowMessage('lObj.Name = ' + lObj.Name);
    ShowMessage('lObj.TestMethode = ' + lObj.TestMethode);
  end;

  if AObj is TUnterklasse then begin
    ShowMessage('AObj.Name = ' + TUnterklasse(AObj).Name);
    ShowMessage('AObj.TestMethode = ' + TUnterklasse(AObj).TestMethode)
  end else
    ShowMessage('keine TUnterklasse');
end;

Wenn immer nur Unterklasse übergeben wird, dann ist es natürlich einfacher, wenn die Methode auch den richtigen Typ besitzt,
procedure TOberklasse.Test(AObj: TUnterklasse);

aber wenn sowohl Oberklasse, als ach Unterklasse übergeben werden kann, dann ist natürlich die gemeinsame Oberklasse das Richtige, und intern eine Prüfung.
procedure TOberklasse.Test(AObj: TOberklasse);

Delphi-Quellcode:

type
  TOberklasse = class(TObject)
    public
      procedure Test(AObj: TOberklasse);
      constructor Create;
  end;

  TUnterklasse = class(TOberklasse)
    public
      Name: String;
      procedure Test(AObj: TUnterklasse); // eventuell noch ein "overload;" dran, oder notfalls ein "reintroduce;", aber hier würde der Compiler normal eh nur meckern, wenn im Vorfahren das Test "virtual" und hier nicht "override" ist
      function TestMethode: String;
      constructor Create;
  end;

Hier wird das Test der Unterklasse nur aufgerufen, wenn die Variable TUnterklasse ist. (und hoffentlich auch ein TUnterklasse in der Variable steckt ... muß aber sowieso, es sei denn jemand hat böse gecastet und die Prüfung des Compilers umgangen)

Delphi-Quellcode:

type
  TOberklasse = class(TObject)
    public
      procedure Test(AObj: TOberklasse); virtual;
      constructor Create;
  end;

  TUnterklasse = class(TOberklasse)
    public
      Name: String;
      procedure Test(AObj: TOberklasse); override;
      function TestMethode: String;
      constructor Create;
  end; 

procedure TOberklasse.Test(AObj: TOberklasse);
begin
  ShowMessage('AObj.ClassName = ' + AObj.ClassName);
end; 

procedure TUnterklasse.Test(AObj: TOberklasse);
begin
  inherited;
  if AObj = TUnterklasse then begin
    ShowMessage('AObj.Name = ' + TUnterklasse(AObj).Name);
    ShowMessage('AObj.TestMethode = ' + TUnterklasse(AObj).TestMethode);
  end;
end;

Hier wird immer das Test der Unterklasse aufgerufen, sobald in der Variable ein Unterklasse drin ist, egal, ob die Variable Ober- oder Unterklasse ist.
xxx.Test(yyy);
Also die Message wird nur angezeigt, wenn sowohl XXX, als auch YYY, ein TUnterklasse ist.
Bzw. ohne Overload, kann bei XXX als TUnterklasse auch nur ein TUnterklasse als Parameter XXX übergeben werden (oder ein Nachfahre von TUnterklasse, aber nie TOberklasse).

Delphi-Quellcode:

type
  TOberklasse = class(TObject)
    public
      procedure Test; virtual; 
      constructor Create;
  end;

  TUnterklasse = class(TOberklasse)
    public
      Name: String;
      procedure Test; override; 
      function TestMethode: String; 
      constructor Create;
  end; 

procedure TOberklasse.Test;
begin
  ShowMessage('ClassName = ' + ClassName);
end; 

procedure TUnterklasse.Test;
begin
  inherited;
  ShowMessage('Name = ' + Name);
  ShowMessage('TestMetode = ' + TestMetode);
end;

[enigma]

Kurzer Nachtrag: ich habe mehrere Unterklassen, die als Parameter für TOberklasse.Test(AObj: TOberklasse) verwendet werden können. Der Übersicht halber habe ich nur eine Unterklasse aufgeführt. Deshalb klappt das mit procedure Test(AObj: TUnterklasse); leider nicht.

Zitat von DeddyH:

Bei mir klappt das ganz wunderbar.

Delphi-Quellcode:

type
  TUnterklasse = class; // Forward-Deklaration

  TOberklasse = class
  public
    procedure Test(AObj: TUnterklasse);  //ich habe mehrere Unterklassen!!!
  end;

  TUnterklasse = class(TOberklasse)
  public
    function TestMethode: String;
  end;

{ TOberklasse }

procedure TOberklasse.Test(AObj: TUnterklasse);
begin
  if Assigned(AObj)  then
    ShowMessage(AObj.TestMethode);
end;

{ TUnterklasse }

function TUnterklasse.TestMethode: String;
begin
  Result := 'Wuppdi';
end;

...

procedure TForm5.Button1Click(Sender: TObject);
var
  lOberObj: TOberklasse;
  lUnterObj: TUnterklasse;
begin
  lUnterObj := nil;
  lOberObj := TOberklasse.Create;
  try
    lUnterObj := TUnterklasse.Create;
    lOberObj.Test(lUnterObj);
  finally
    lOberObj.Free;
    lUnterObj.Free;
  end;
end;

[TiGü]

Die Struktur ist doch schon so Murks!

Mach einen gemeinsamen Vorfahren (TOberklasse) für deine 1 bis N Unterklassen (TUnterklasse1..TUnterklasse999) aber die Methode, wo du auf Instanzen dieser Klassen reinbekommst (procedure Test(AObj: TUnterklasse); ) packst du ein eine dritte Klasse. Also ein Handler, Manager, Processor, Dispatcher -> nenn es wie es passend erscheint.

[Stolle58]

Hi,

wenn ich Mir deinen Code ansehe, stelle ich fest das Du ein Anfänger bist und den Aufbau von Klassen noch nicht ganz verstehst.

Deshalb möchte ich dir einen Youtube Kanal nennen, von dem du vieles lernen kannst.

https://www.youtube.com/@DelphiLernen/videos

Ich wünsche dir viel erfolg beim lernen.

[DeddyH]

Vor 16 Jahren registriert und immer noch Anfänger?

[enigma]

Hallo an euch,
es kann sein, dass ich euch für euch einfache Fragen stelle,
aber ich freue mich auf eure Tipps 😉