Zwei Klassen in einer ObjectList

[totti14]

Hallo,
ich habe zwei Klassen mit den selben public proceduren.
Die beide Klassen werden eigentlich nur beim erzeugen unterschieden. Je nachdem auf welchen Port die Daten rein kommen.
Jeder Klasse macht natürlich was anderes in Send und Verarbeite.
Diese wollte ich dann einer Generetic Objectlist verwalten. Die scheinen in D2010 ja gut zu funktionieren ?

Delphi-Quellcode:

Type
  TProt1 = class
    private
      procedure MachWasAB;
    public
      constructor create;
      procedure Send(const Buf : Array of byte);
      procedure Verarbeite;
  end;

  TProt2 = class
    private
      procedure MachWasABC;
    public
      constructor create;
      procedure Send(Const Buf : Array of Byte);
      procedure Verarbeite;
  end;

Var
  ClientList: TObjectList<TProt1>;

Delphi-Quellcode:

MAIN

  ClientList:=TObjectList<TProt1>.create;
........
  if Port = 300 then
  ClientList.Add(TProt2.create)     //  das geht natürlich nicht
  else
  ClientList.Add(TProt1.create);

  ........
  ClientList[i].Send(Data];

Da gibt es doch bestimmt eine bessere Lösung dafür ?

Besten Dank

[mirage228]

Du könntest beide Klassen von einer abstrakten Basisklasse ableiten, die die gemeinsamen public Methoden ebenfalls als abstrakt definiert. Von dieser Basisklasse könntest Du die generische ObjectList erstellen...

[Neutral General]

Hallo und Willkommen im Land der Objektorientierung :mrgreen:

Du leitest einfach TProt2 von TProt1 ab:

Delphi-Quellcode:

type
 TProt1 = class 
    protected
      procedure MachWasAB; virtual;
    public 
      constructor create; virtual;
      procedure Send(const Buf : Array of byte); virtual;
      procedure Verarbeite; virtual;
  end; 

  TProt2 = class(TProt1)
    protected
      procedure MachWasABC; override;
    public 
      constructor create; override;
      procedure Send(Const Buf : Array of Byte); override;
      procedure Verarbeite; override;
  end; 

Var 
  ClientList: TObjectList<TProt1>;

oder erstellst eine (abstrakte) Oberklasse:

Delphi-Quellcode:

type
 TProt = class abstract
    protected
      procedure MachWasAB; virtual; abstract;
    public 
      procedure Send(const Buf : Array of byte); virtual; abstract;
      procedure Verarbeite; virtual; abstract;
  end; 

  TProt1 = class(TProt)
    protected
      procedure MachWasAB; override;
    public 
      constructor create; virtual;
      procedure Send(const Buf : Array of byte); override;
      procedure Verarbeite; override;
  end; 

  TProt2 = class(TProt1)
    protected
      procedure MachWasABC; override;
    public 
      constructor create; override;
      procedure Send(Const Buf : Array of Byte); override;
      procedure Verarbeite; override;
  end;

Var 
  ClientList: TObjectList<TProt>;

[dominikkv]

Ich würde das ganze über Ableitungen lösen:

Delphi-Quellcode:

Type
  TBasicProt = class(TObject)
  public
    procedure Send(const Buf : Array of byte); virtual; abstract;
    procedure Verarbeite; virtual; abstract;   
  end;

  TProt1 = class(TBasicProt)
    private
      procedure MachWasAB;
    public
      constructor create;
      procedure Send(const Buf : Array of byte); override;
      procedure Verarbeite; override;
  end;

  TProt2 = class(TBasicProt)
    private
      procedure MachWasABC;
    public
      constructor create;
      procedure Send(Const Buf : Array of Byte); override;
      procedure Verarbeite; override;
  end;

Var
  ClientList: Array of TBasicProt; // oder auch eine andere Liste

[totti14]

Wow. In 2 Minuten soviele Antworten.
Bei OOP hatte ich schon immer ein Brett vor der Rübe :) Kommt im Embedded Pascal nicht vor.

Bei meiner Generetic Objectlist wollte ich schon bleiben, da mein Prog so schon läuft.
Ich wollte es nur erweitern.

Ich werde Eure Vorschläge mal probieren.

Danke

Wobei hier hakt es wieder bei mir:

Zitat:

oder erstellst eine (abstrakte) Oberklasse:

Delphi-Quellcode:

   type
TProt = class abstract
    protected
      procedure MachWasAB; virtual; abstract;
    public
      procedure Send(const Buf : Array of byte); virtual; abstract;
      procedure Verarbeite; virtual; abstract;
  end;

  TProt1 = class(TProt)
    protected
      procedure MachWasAB; override;
    public
      constructor create; virtual;
      procedure Send(const Buf : Array of byte); override;
      procedure Verarbeite; override;
  end;

  TProt2 = class(TProt1)
    protected
      procedure MachWasABC; override;
    public
      constructor create; override;
      procedure Send(Const Buf : Array of Byte); override;
      procedure Verarbeite; override;
  end;

Var
  ClientList: TObjectList<TProt>;

ClientList.Add(TProt2.Create); funzt ja nicht ?
EDIT: Sorry. Das funktioniert ja sogar :)
Aber jetzt mag er mein MachWasABC in TProt2 nicht. Gibt ja auch nicht in der Basis Klasse.

:gruebel:

[Neutral General]

Zitat:

Zitat von totti14

Aber jetzt mag er mein MachWasABC in TProt2 nicht. Gibt ja auch nicht in der Basis Klasse.
:gruebel:

Nunja entweder musst du die Methode in die Basisklasse aufnehmen (als abstrakte Methode) oder du musst halt ggf. casten.

Deine MachWasABC; kannst/darfst du in Prot2 übrigens nicht überschreiben. Die wurde vorher ja nicht definiert. Das habe ich in meinem Code auch übersehen. Je nachdem musst du MachWasAB und MachWasABC auch gar nicht in die Basisklasse aufnehmen und dann überschreiben. Dann kannst du sie als private in jeder Klasse implementieren. Aber das kommt halt auf den Anwendungszweck drauf an.

[totti14]

Jo.
Jede Klasse hat halt noch ein paar interne Funktionen. Diese werden nur von Send gebraucht.

[Neutral General]

OK. Diese internen brauchst du dann nicht in die Basisklasse zu tun.

[totti14]

Delphi-Quellcode:

type
TProt = class abstract       
    public
      procedure Send(const Buf : Array of byte); virtual; abstract;
      procedure Verarbeite; virtual; abstract;
  end;

  TProt1 = class(TProt)
    privat
      procedure MachWasAB;
      procedure MachWasABC;
      procedure MachWasABCD;
    public
      constructor create; virtual;
      procedure Send(const Buf : Array of byte); override;
      procedure Verarbeite; override;
  end;

  TProt2 = class(TProt1)
    privat
      procedure MachWasABCDE;
      procedure MachWasABCDEF;
    public
      constructor create; override;
      procedure Send(Const Buf : Array of Byte); override;
      procedure Verarbeite; override;
  end;

Dann würde TProt2 ja alles unnütze private von TProt1 erben ?

[Neutral General]

Private Felder und Methoden werden nicht vererbt :wink: