Basisklasse und davon abgeleitet drei Standardklassen

[s-off]

Hallo zusammen,
irgendwie stehe ich gerade derbe auf dem Schlauch, und hoffe, mir kann just jemand auf die Sprünge helfen.

Folgendes:
Ich möchte eine Basisklasse TBasisklasse haben, welche ein paar Eigenschaften und ein paar Methoden hat.

Nun möchte ich von dieser Basisklasse drei Kindklassen ableiten. Diese sollen einmal die Eigenschaften und Methoden von der Basisklasse erben, aber eigentlich wie ein TEdit, TLabel bzw. TMemo sein (nur als Beispiel).

Also ungefähr so:

Delphi-Quellcode:

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

   TEditklasse = Class(TBasisklasse)

   End;

   TLabelklasse = class(TBasisklasse)

   end;

   TMemoklasse = Class(TBasisklasse)

   End;

Wenn ich nun also ein Objekt aus der Klasse TEditklasse erzeuge, möchte ich im Prinzip ein TEdit haben, welches aber zusätzlich über die Eigenschaften aus TBasisklasse verfügt.
Der Grund: Wenn an 'SetWind' etwas geändert werden muss, muss dieses dann nur in der Basisklasse gemacht werden.

Ich weiß, dass sich das ziemlich wirr anhört, aber ich hoffe, dass meine Intention jemand versteht.
Ich weiss absolut nicht, wie ich das aufbauen soll

[quendolineDD]

Ich würde erstmal die Basisklasse von TObject ableiten.
Inwiefern meinst du, du willst ein TEdit, ein TLabel und ein TMemo von TBasisklasse ableiten?
Welche Proceduren willst du denn übertragen? Ich sehe nirgends ein virtual / override.

Eventuell wäre eine präzisere Formulierung deines Anliegens hilfreich

Zitat:

Wenn ich nun also ein Objekt aus der Klasse TEditklasse erzeuge, möchte ich im Prinzip ein TEdit haben, welches aber zusätzlich über die Eigenschaften aus TBasisklasse verfügt.

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

Zitat:

Das Deklarieren einer Eigenschaft ohne Angabe eines Typs nennt man Überschreiben. Diese Vorgehensweise ermöglicht das Ändern der geerbten Sichtbarkeit bzw. des geerbten Bezeichners einer Eigenschaft. In der einfachsten Form braucht nur das reservierte Wort property zusammen mit einem geerbten Eigenschaftsbezeichner angegeben zu werden. Auf diese Weise kann die Sichtbarkeit der betreffenden Eigenschaft geändert werden. So kann beispielsweise eine in einer Vorfahrklasse als protected deklarierte Eigenschaft im public- oder published-Abschnitt einer abgeleiteten Klasse neu deklariert werden. Eigenschaftsüberschreibungen können die Angaben read, write, stored, default und nodefault enthalten, durch die die entsprechende geerbte Direktive außer Kraft gesetzt wird. Mithilfe einer Überschreibung können Sie geerbte Zugriffsangaben ersetzen, fehlende Angaben hinzufügen oder den Gültigkeitsbereich einer Eigenschaft erweitern, jedoch keine Zugriffsbezeichner entfernen oder die Sichtbarkeit verringern. Optional kann auch mit der Direktive implements die Liste der implementierten Schnittstellen ergänzt werden, ohne die geerbten Schnittstellen zu entfernen.

Die folgenden Deklarationen zeigen, wie Eigenschaften überschrieben werden können:

type
TAncestor = class
...
protected
property Size: Integer read FSize;
property Text: string read GetText write SetText;
property Color: TColor read FColor write SetColor stored False;
...
end;
type
TDerived = class(TAncestor)
...
protected
property Size write SetSize;

published
property Text;
property Color stored True default clBlue;
...
end;

Beim Überschreiben von Size wird die Angabe write hinzugefügt, damit der Wert der Eigenschaft geändert werden kann. Die Sichtbarkeit der Eigenschaften Text und Color wird von protected in published geändert. Für die Eigenschaft Color wird außerdem festgelegt, dass sie in der Formulardatei gespeichert wird, wenn sie einen anderen Wert als clBlue hat.

Wenn Sie beim Redeklarieren einer Eigenschaft einen Typbezeichner angeben, wird die geerbte Eigenschaft nicht überschrieben, sondern lediglich verdeckt. Dadurch wird eine neue Eigenschaft mit demselben Namen wie die geerbte erstellt. Diese Art der Deklaration muss immer vollständig vorgenommen werden. Stets muss zumindest eine Zugriffsangabe vorhanden sein.

Unabhängig davon, ob eine Eigenschaft in einer abgeleiteten Klasse verdeckt oder überschrieben wird, erfolgt die Suche nach der Eigenschaft immer statisch. Der deklarierte (also zur Compilierzeit bekannte) Typ der Variablen bestimmt die Interpretation des Eigenschaftsbezeichners. Aus diesem Grund wird nach dem Ausführen des folgenden Codes durch das Lesen oder Schreiben von MyObject.Value die Methode Method1 bzw. Method2 aufgerufen, obwohl MyObject eine Instanz von TDescendant enthält. Sie können aber durch eine Typumwandlung in TDescendant auf die Eigenschaften und Zugriffsangaben der abgeleiteten Klasse zugreifen.

type
TAncestor = class
...
property Value: Integer read Method1 write Method2;
end;
TDescendant = class(TAncestor)
...
property Value: Integer read Method3 write Method4;
end;
var MyObject: TAncestor;
...
MyObject := TDescendant.Create;

[mkinzler]

Von TObject brauchst du nicht explizit ableiten, da das auf jeden Fall geschieht. Jede Klasse in Delphi erbt automatisch direkt oder indirekt von TObject.

[Sidorion]

Das was Du benötigst ist ein Interface und eine zugehörige Delegatenklasse. Such mal in der OH nach 'Interface' und 'implements'. Das Interface schreibst du dann zusätzlich in die Klassendeklaration (=class(TBasisklasse,Interface)). In dem Interface implementierst Du dann die Methoden, die jetzt deine Basisklasse besitzt. Interfaces umgehen das Problem, dass in Delphi keine Mehrfachvererbung möglich ist.

[s-off]

Zitat von quendolineDD:

Ich würde erstmal die Basisklasse von TObject ableiten.

Da bin ich mkinzlers Meinung

Zitat von quendolineDD:

Eventuell wäre eine präzisere Formulierung deines Anliegens hilfreich

Wenn das so einfach wäre

Also:
Erzeuge ich mir ein Objekt von TEditklasse, dann möchte ich, dass auf meiner Form ein TEdit erscheint, welches aber zusätzlich die Eigenschaft 'Wind' aus der Basisklasse besitzt.
Erzeuge ich mir ein Objekt von TLabelklasse, dann möchte ich, dass auf meiner Form ein TLabel erscheint, welches aber zusätzlich die Eigenschaft 'Wind' aus der Basisklasse besitzt.
Erzeuge ich mir ein Objekt von TMemoklasse, dann möchte ich, dass auf meiner Form ein TMemo erscheint, welches aber zusätzlich die Eigenschaft 'Wind' aus der Basisklasse besitzt.

Muss ich Änderungen an 'SetWind' vornehmen, so mache ich das nur in der Basisklasse - die Änderungen übertragen sich auf die drei Kindklassen.
Dass das so, wie ich es oben dargestellt habe, nicht funktionieren kann, ist klar. Sollte das Ganze nur veranschaulichen.

Werde mir das mit den Interfaces von Sidorion mal zu Gemüte führen.

[Jelly]

Das wird so nicht gehen. Und zwar weil du erweiterte Klassen von TEdit, TMemo und TLabel haben willst. Deine TBasisklasse kann aber nicht von allen 3 erben.

Es bleibt dir wohl nichts anderes übrig, als 3 neue Unterklassen von TEdit, TMemo und TLabel zu erstellen, und dort jeweils als Referenz auf deine TBasisklasse zu referieren (Assoziation im UML Jargon)

[s-off]

Zitat von Jelly:

Es bleibt dir wohl nichts anderes übrig, als 3 neue Unterklassen von TEdit, TMemo und TLabel zu erstellen, und dort jeweils als Referenz auf deine TBasisklasse zu referieren (Assoziation im UML Jargon)

Und das geht mit den von Sidorion gennanten Interfaces? Oder geht das wieder in eine andere Richtung. (Kam noch nicht soweit, das Thema 'Interface' in der Hilfe nachzuschlagen.)

[Phoenix]

Zu meiner Schande habe ich in Delphi noch nie mit Interfaces gearbeitet, aber wenn die so funktionieren wie in .NET, dann hilft das nicht.

In dem Fall wäre ein interface nur eine Erweiterung der Klasse die sagt: "Diese Klasse hier hat diese Properties und diese Methoden.". Die Implementierung des Interfaces - im konkreten Fall die SetWind Methode und das Property Wind - müssen jedoch auf jeder Klasse die das Interface verwendet selber implementiert werden.

[Apollonius]

In Interfaces kannst du nur Methoden und Propertys, aber keine Felder definieren, außerdem keine Implentierung, also nur abstrakt. Und dann müsstest du in jeder Klasse den Code für SetWind einfügen.
Das sind solche Fälle, in denen man sich echte Mehrfachvererbung wie in C++ wünscht.

[s-off]

Hmm,

Interface scheint tatsächlich nicht das Richtige zu sein.
Dort habe ich ja keine Möglichkeit Felder zu deklarieren.

Edit: Wie Apollonius sagt

Aber nochmal: Mehrfachvererbung würde ja bedeuten, dass meine TBasisklasse von den drei Standardklassen erben würde.
Ich möchte es aber ja genau andersrum: Die drei Standardklassen sollen ja die Felder und Methoden der Basisklasse erben.