Gleicher Prozedurenname - Anderer Parametertyp

[Getox]

Hallo, ich stehe hier etwas auf dem Schlauch. Vielleicht hat jemand eine Idee wie ich das regeln kann.

Ich habe ein Objekt, welches eine Prozedur bekommen soll "GetTask()". Ich möchte, dass Dieses Objekt nur "Befehle" über diese eine Methode entgegennehmen kann.

Der Parameter ist aber auch ein Objekt. Genau genommen kann der Parameter eines von 3 verschiedenen Objekten sein...

Ich möchte also, dass ich die "GetTask()"-Methode mit einem beliebigen dieser 3 Objekte ansprechen kann und dann aufgrund des übergebenen Objekttyps entschieden werden kann, wie damit weiter verfahren werden kann.

Wie kann ich eine Methode erstellen die eines von 3 verschiedenen Objekten annehmen und diese danach unterscheiden kann?

Edit: In was für einer Kategorie ist denn mein Thread jetzt gelandet? o.O ich glaube ich hab mich verklickt... vielleicht mag das ja jemand kurz richtig schieben...

[Klaus01]

.. haben die 3 Klassen eine gemeinsame Elternklasse?

Grüße
Klaus

[mkinzler]

Haben die Objekte einen gemeinsamen Vorfahren?
Man könnte die Methode überladen.

[Popov]

Zuerst grob würde ich vorschlagen TObject. In der Prozedur selbst abfragen um was für eine Klasse es sich handelt.

[Getox]

Also eines der 3 Objekte ist die Elternklasse und die anderen beiden sind von dieser abgeleitet.

[swkevin08]

Vlt kannst du dein Problem mithilfe einer abstrakten Klasse lösen. =)

[Popov]

Vielleicht denke ich zu einfach oder zu kompliziert, aber sowas vielleicht in der Art?

Delphi-Quellcode:

type
  TTest = class
  private
    procedure DreiObjekte2(x: TObject);
  public
    property DreiObjekte: TObject write DreiObjekte2;
  end;

procedure TTest.DreiObjekte2(x: TObject);
begin
  if (x is TBitmap) then
  begin
    ShowMessage('TBitmap');
  end;

  if (x is TStrings) then
  begin
    ShowMessage('TStrings');
  end;

  if (x is TButton) then
  begin
    ShowMessage('TButton');
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  Test: TTest;
begin
  Test := TTest.Create;
  try
    Test.DreiObjekte := Image1.Picture.Bitmap;
    Test.DreiObjekte := Memo1.Lines;
    Test.DreiObjekte := Button1;
  finally
    Test.Free;
  end;
end;

[Volker Z.]

Hallo,

vielleicht hilft Dir folgendes weiter:

Delphi-Quellcode:

TForm4 = class(TForm)
    Button1: TButton;
    Edit1: TEdit;
    Memo1: TMemo;
    RichEdit1: TRichEdit;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    procedure GetTask (Obj : TCustomEdit); overload;
    procedure GetTask (Obj : TEdit); overload;
    procedure GetTask (Obj : TMemo); overload;
  end;

procedure TForm4.Button1Click(Sender: TObject);
begin
  GetTask (Edit1);
  GetTask (Memo1);
  GetTask (Richedit1);
end;

procedure TForm4.GetTask(Obj: TCustomEdit);
begin
  ShowMessage ('Bin ein CustomEdit')
end;

procedure TForm4.GetTask(Obj: TEdit);
begin
  ShowMessage ('Bin ein Edit')
end;

procedure TForm4.GetTask(Obj: TMemo);
begin
  ShowMessage ('Bin ein Memo')
end;

Ausgabe:
Bin ein Edit
Bin ein Memo
Bin ein CustomEdit

Gruß

[Getox]

Ah... ihr braucht euch keine Gedanken mehr für mich machen...

Als Basisobjekt übergeben, mit "is" prüfen, was es ist und mit "as" als das, was es halt ist benutzen.

Vielen Dank, manchmal brauch ich halt nur einen kleinen Anstoß :P

[gmc616]

Zitat:

Zitat von Getox (Beitrag 1201343)

Der Parameter ist aber auch ein Objekt. Genau genommen kann der Parameter eines von 3 verschiedenen Objekten sein...

Ich möchte also, dass ich die "GetTask()"-Methode mit einem beliebigen dieser 3 Objekte ansprechen kann und dann aufgrund des übergebenen Objekttyps entschieden werden kann, wie damit weiter verfahren werden kann.

Ich hätte auch noch einen ...

Delphi-Quellcode:

interface

Type
  TParentClass = class;

  TParentClass = Class (Tobject)
  public
    Procedure GetTask(AClass : TParentClass); overload;
  End;


  TChildA = Class (TParentClass)
  public
    Procedure GetTask(AClass : TParentClass); OverLoad;
  End;

  TChildB = Class (TParentClass)
  public
    Procedure GetTask(AClass : TParentClass); OverLoad;
  End;

implementation

{ TParentClass }
procedure TParentClass.GetTask(AClass: TParentClass);
begin
  if AClass is TChildA then
    TChildA(AClass).GetTast(AClass)

  else if AClass is TChildB then
    TChildB(AClass).GetTast(AClass)

end;

{ TChildA }
procedure TChildA.GetTask(AClass: TParentClass);
begin
  ShowMessage('Child A');
end;

{ TChildB }
procedure TChildB.GetTask(AClass: TParentClass);
begin
  ShowMessage('Child B');
end;


procedure TForm1.Button3Click(Sender: TObject);
var
  MyClassA : TChildA;
  MyClassB : TChildB;
begin

  MyClassA := TChildA.Create;
  TParentClass(MyClassA).GetTast(MyClassA);

  MyClassB := TChildB.Create;
  TParentClass(MyClassB).GetTast(MyClassB);


end;

[uligerhardt]

Zitat:

Zitat von Getox (Beitrag 1201354)

Als Basisobjekt übergeben, mit "is" prüfen, was es ist und mit "as" als das, was es halt ist benutzen.

Fast. Richtig ist: Als Basisobjekt übergeben, mit "is" prüfen, was es ist, und mit "(...)" (harter Cast -

Delphi-Quellcode:

TEdit(obj)

) als das, was es halt ist, benutzen. :mrgreen:

[DeddyH]

Ich hab auch noch einen:

Delphi-Quellcode:

type
  TVater = class
  public
    procedure SayHello; virtual;
  end;

  TSohn = class(TVater)
  public
    procedure SayHello; override;
  end;

  TTochter = class(TVater)
  public
    procedure SayHello; override;
  end;

  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
    procedure GetTask(Klasse: TVater);
  public
    { Public-Deklarationen }
  end;

...

procedure TVater.SayHello;
begin
  ShowMessage('Hallo von der Vaterklasse');
end;

procedure TSohn.SayHello;
begin
  ShowMessage('Hallo von der Sohnklasse');
end;

procedure TTochter.SayHello;
begin
  ShowMessage('Hallo von der Tochterklasse');
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  Vater: TVater;
  Sohn: TSohn;
  Tochter: TTochter;
begin
  Vater := TVater.Create;
  try
    GetTask(Vater);
  finally
    Vater.Free;
  end;
  Sohn := TSohn.Create;
  try
    GetTask(Sohn);
  finally
    Sohn.Free;
  end;
  Tochter := TTochter.Create;
  try
    GetTask(Tochter);
  finally
    Tochter.Free;
  end;
end;

procedure TForm1.GetTask(Klasse: TVater);
begin
  Klasse.SayHello;
end;

[uligerhardt]

Zitat:

Zitat von DeddyH (Beitrag 1201363)

Ich hab auch noch einen:

Delphi-Quellcode:

type
  TVater = class
  public
    procedure SayHello; virtual;
  end;

  TSohn = class(TVater)
  public
    procedure SayHello; override;
  end;

  TTochter = class(TVater)
  public
    procedure SayHello; override;
  end;

  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
    procedure GetTask(Klasse: TVater);
  public
    { Public-Deklarationen }
  end;

...

procedure TVater.SayHello;
begin
  ShowMessage('Hallo von der Vaterklasse');
end;

procedure TSohn.SayHello;
begin
  ShowMessage('Hallo von der Sohnklasse');
end;

procedure TTochter.SayHello;
begin
  ShowMessage('Hallo von der Tochterklasse');
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  Vater: TVater;
  Sohn: TSohn;
  Tochter: TTochter;
begin
  Vater := TVater.Create;
  try
    GetTask(Vater);
  finally
    Vater.Free;
  end;
  Sohn := TSohn.Create;
  try
    GetTask(Sohn);
  finally
    Sohn.Free;
  end;
  Tochter := TTochter.Create;
  try
    GetTask(Tochter);
  finally
    Tochter.Free;
  end;
end;

procedure TForm1.GetTask(Klasse: TVater);
begin
  Klasse.SayHello;
end;

Das wird mir jetzt aber zu OO-orthodox. :mrgreen:

[DeddyH]

Ich dachte mir nur: wenn es eigene Klassen sind, wozu dann casten? ;)

[Sir Rufo]

Eine schicke Alternative hätte ich noch mit dem Visitor-Pattern in der Raabe-Edition :)

Achtung: Nur mit Delphi 2010 und aufwärts