Basisklasse und davon abgeleitet drei Standardklassen

[mkinzler]

Mehrfachvererbung bringt mehr Probleme als Vorteile, deshalb findet man sie nicht in neuren Sprachen wie Java, Delphi, C#, ..., wo man Vererbung per Interfaces präferiert.

[s-off]

Zitat von quendolineDD:

Da TEdit ja abgeleitet wird von TBasisklasse, übernimmt es schon automatisch dessen Eigenschaften, welche in Public und in protected sich befinden.

Ähm, das ist mir schon klar - ein bissel OOP verstehe ich schon, aber:
TEdit wird nicht von Basisklasse abgeleitet.
Ich möchte eine Klasse, deren Instanz der eines TEdit entspricht, zusätzlich aber die Eigenschaften aus TBasisklasse übernimmt.

Und wie ich schon schrieb: so, wie ich das im Delphi-Code meines ersten Beitrages dargestellt habe, kann das nicht funktionieren; das weiß ich. Aber genau dort liegt ja mein Problem - ich weiß nicht, wie ich dieses Konstrukt erzeugen soll.

Edit:
was ich nicht möchte, ist soetwas:

Delphi-Quellcode:

Type
   TEditklasse = Class(TEdit)
   private
      FEigenschaft1: Integer;
      FEigenschaft2: Integer;
      FEigenschaft3: Integer;
      FWind: String;
      Procedure SetWind(Const Value: Integer);
   public
       Property Wind: String read FWind write SetWind;
   End;

   TLabelklasse = class(TLabel)
   private
      FEigenschaft1: Integer;
      FEigenschaft2: Integer;
      FEigenschaft3: Integer;
      FWind: String;
      Procedure SetWind(Const Value: Integer);
   public
       Property Wind: String read FWind write SetWind;
   end;

   TMemoklasse = Class(TMemo)
   private
      FEigenschaft1: Integer;
      FEigenschaft2: Integer;
      FEigenschaft3: Integer;
      FWind: String;
      Procedure SetWind(Const Value: Integer);
   public
       Property Wind: String read FWind write SetWind;
   End;

[Apollonius]

Mehrfachvererbung wäre hier sehr praktisch. Du könntest einfach schreiben
 TEditklasse=class(TEdit, TBasisklasse) und fertig wärst du. Ich habe mir auch schon eine weniger eingeschränkte Form der Mehrfachvererbung gewünscht, als es sie in Delphi gibt. Das Diamond-Problem (das meintest du doch, mkinzler?!) wurde in C++ ja sehr gut mit virtueller Vererbung gelöst, und die Spezialfälle, bei denen es vorkommt, ließen sich bestimmt auch anders vermeiden oder verbieten.

[s-off]

Zitat von Apollonius:

Mehrfachvererbung wäre hier sehr praktisch. Du könntest einfach schreiben
 TEditklasse=class(TEdit, TBasisklasse)

Ja, das wäre was

Wenn doch so viele Leute eine solche Funktionalität gerne hätten - gibt es dann keinen 'Workaround'?
Interfaces sind es ja aufgrund der nicht vorhandenen Möglichkeit, Felder etc. zu deklarieren, nicht.

Und nein - für mich ist kein Workaround, das Ganze in C-basierten Sprachen zu realisieren
Abgesehen davon, dass ich kein C[x] beherrsche, sind mir meine Arbeitsmittel vorgegeben.

[Khabarakh]

An Workarounds mangelt es nicht, dafür müsste man aber erst etwas mehr von den Hintergründen erfahren; man möchte schließlich das freakigstmögliche Design-Pattern einsetzen . Z.B. könnte es sinnvoll sein, das ganze als Factory-Interface zu gestalten:

Delphi-Quellcode:

type
  IMyFactory = interface
    function CreateSomething : TBasisklasse;
  end;

[...]

function TMyEdit.CreateSomething;
begin
  Result := TEditklasse.Create;
end;

Oder auch einfach als

Delphi-Quellcode:

type
  IMyExtender = interface
    function GetSomething : TBasisklasse;
    property Something : TBasisklasse read GetSomething;
  end;

(Alle Angaben ohne Gewähr, hab Interfaces in Delphi nur ein-, zweimal benutzt)

[s-off]

Zitat von Khabarakh:

man möchte schließlich das freakigstmögliche Design-Pattern einsetzen

Naja, zu den Hintergründen - den Sinn habe ich ja bereits erläutert, und ich sehe ein, dass Mehrfachvererbung eine nette Sache wäre.

Ich habe es jetzt so gelöst, dass ich einfach in der Basisklasse ein Feld 'FControl' und eine entsprechende Property dazu erstellt habe, dem ich dann im Constructor, den ich in den Kindklassen überschreibe, einfach eine Instanz der entsprechenden Klasse zuweise, und erst danach den Constructor der Basisklasse aufrufe.
Dann spreche ich das Ganze halt hinterher nicht nur mit dem Instanzennamen an, sondern mit Instanzenname.Control
Mit Mehrfachvererbung hätte mir zwar besser gefallen, aber so gehts auch.

Delphi-Quellcode:

   TBasisklasse = Class
   private
      FControl: TControl;
      FEigenschaft1: Integer;
      FEigenschaft2: Integer;
      FWind: Integer;
      Procedure SetWind(Const Value: Integer);
   public
      Constructor Create(AOwner: TComponent); virtual;
      Property Control: TControl read FControl;
      Property Wind: Integer read FWind write SetWind;
   End;

   TEditklasse = Class(TBasisklasse)
   public
      Constructor Create(AOwner: TComponent); override;
   End;

   TLabelklasse = Class(TBasisklasse)
      Constructor Create(AOwner: TComponent); override;
   End;

   TMemoklasse = Class(TBasisklasse)
      Constructor Create(AOwner: TComponent); override;
   End;

[...]

Constructor TBasisklasse.Create(AOwner: TComponent);
Begin
   FEigenschaft1: FControl.Width;
   FEigenschaft2: FControl.Height;
End;

Procedure TBasisklasse.SetWind(Const Value: Integer);
Begin
   FWind := Value;
   FControl.Width := FEigenschaft1 * Value;
   FControl.Height := FEigenschaft2 * Value;
End;

Constructor TEditklasse.Create(AOwner: TComponent);
Begin
   FControl := TEdit.Create(AOwner);
   Inherited;
End;

Constructor TLabelklasse.Create(AOwner: TComponent);
Begin
   FControl := TLabel.Create(AOwner);
   Inherited;
End;

Constructor TMemoklasse.Create(AOwner: TComponent);
Begin
   FControl := TMemo.Create(AOwner);
   Inherited;
End;

Edit: freue mich natürlich noch immer über anderweitige Lösungsmöglichkeiten, wenn Ihr welche habt

[Hansa]

Hier steht nicht viel brauchbares ! Das einzige wäre ein Tedit und ein TMemo. Die besitzen zumindest mal Editier-Funktionalitäten. Ein TLabel hat nicht mal die. Wozu soll dieser unzusammenhängende Kram jetzt zusammengeschmissen werden ? Wird ein spezielles TEdit gebraucht, dann leite das von TEdit ab usw. Die Funktionalität bei TObject (= bei Null) etc. angefangen selber einzubauen ist völliger Blödsinn.

[Dax]

Wenn ich mich jetzt nicht vollkommen vertue, könnten Class Helpers was für dich sein. Das sind Klassen, die du an die Klasse, der sie "helfen", direkt anheftest. Die Klasse hat also zusätzlich diese Felder, Methoden, ... Einzige Einschränkung ist, dass die Unit mit den Helferklassen in der uses-Klausel der verwendenden Units stehen muss.

[Jens Schumann]

Hallo,
wenn ich mich recht erinnere gibt es für Delphi mittlerweile ClassHelper.
Mal hier im Forum suchen. Wenn man keine property sondern nur eine
Setter und Getter Methode für WInd verwendet könnte man einen
Classhelper verwenden.

[Apollonius]

Ich habe auch schon daran gedacht, aber Helferklassen können keine Felder enthalten.