Verschachtelte Objekte

[Sadum]

Hallo,

Ich möchte gerne Objekte direkt wie 'Stammbäume' verwalten, um allgemeine Probleme immer weiter in 'Unterobjekte' zu sortieren, anstelle durch Vererbung einen ungeordneten Haufen Nachfahren zu erzeugen.

Also zum Beispiel (Pseudo Code):

Fahrzeug.PKW.Jeep.bauen;

Anstelle von:

PKW = class (Fahrzeug);
Jeep = class (PKW);
Jeep.bauen;

Das Problem ist nur, dass ich zwar Unterobjekte in Objekte stecken kann, diese aber leider die Methoden und Felder des Objektes in dem sie stecken nicht nutzen können (man könnte in Jeep.bauen ja z.B. eine bereits vorhandene Prozedur PKW.bauen des übergeorneten Objekts 'PKW' verwenden wollen), da wenn ich sie als Nachfahren des übergeordneten Objekts deklariere, ich sie nicht auch schon als einen Bestandteil des übergeordneten Objekts verwendet haben darf (was aber für die Schachtelung nötig ist).

[mkinzler]

Das von dir angestrebte System hat einen eklatanten Nachteil: wenn du einen neuen Nacfahren hinzufügst, mußt du das komplette System anpassen. Ich sehe auch keinen Vorteil in dieser Vorgehensweise. was gefällt dir an Vererbung nicht?

[DGL-luke]

Hallo, virtuelle Methoden sind dein Mittel der Wahl.

Delphi-Quellcode:

type
  TAuto = class
  public
    procedure Bauen; virtual; abstract;
  end;

  TJeep = class(TAuto)
  public
    procedure Bauen; override;
  end;

So kannst du jederzeit jeep.Bauen oder (jeep as TAuto).Bauen aufrufen, auch wenn du so was hast:

Delphi-Quellcode:

function IrgendeinAuto:TAuto;
begin
  if Random > 0.5 then
    Result := TJeep.Create
  else
    Result := TPKWCreate;
end;

Kannst du sowas machen:

Delphi-Quellcode:

with IrgendeinAuto do
begin
  Bauen;
  {Fahren;
  Verschrotten;} //nur so als beispiel ;)
  Free;
end;

EDIT: Wobei das, was du jetzt hier willst, mir eher sinnlos erscheibnt. So eine Klassen"hierarchie", mein ich :gruebel:

[HalloDu]

Ich würde es mal so versuchen:

Delphi-Quellcode:

type TPKW = class
     Jeep: TJeep
     procedure Fahren;
     end;
type TJeep = class
     Wuestenjeep: TWuestenjeep;
     GelaendeIndex: Integer;
     end;
type TWuestenjeep = class
     procedure Springen;
     end;

Damit könntest du dann in solche Konstrukte bauen: PKW.fahren; PKW.Jeep.GeleandeIndex; PKW.Jeep.Wuestenjeep.Springen; Trotzdem würde ich dir die gute alte Vererbung empfehlen.

Hoffe es hilt dir beim :coder2:

Mfg HalloDu

EDIT: Ich kann meinen Vorrednern nur zustimmen: Versuch es mit Vererbung.

[Sadum]

Zitat:

Zitat von mkinzler

Das von dir angestrebte System hat einen eklatanten Nachteil: wenn du einen neuen Nacfahren hinzufügst, mußt du das komplette System anpassen. Ich sehe auch keinen Vorteil in dieser Vorgehensweise. was gefällt dir an Vererbung nicht?

Ich finde damit ist alles einfach besser sortiert.
Delphi selbst verwendet diese Vorgehensweise doch auch:

form1.label1.caption := 'Test';

oder noch stärker bei TWebBrowser:

form1.WebBrowser1.OleObject.document.forms.item(nr ).elements.item(nr).click;

Zitat:

Zitat von HalloDu

Ich würde es mal so versuchen:

Delphi-Quellcode:

type TPKW = class
     Jeep: TJeep
     procedure Fahren;
     end;
type TJeep = class
     Wuestenjeep: TWuestenjeep;
     GelaendeIndex: Integer;
     end;
type TWuestenjeep = class
     procedure Springen;
     end;

Es ist gerade mein Problem, dass eben so etwas nicht geht, weil ich bei der Deklaration von TPKW, den Ausdruck 'Jeep: TJeep'
gar nicht verwenden darf, da TJeep noch gar nicht bekannt ist!

[HalloDu]

Delphi muss das benutzen, weil dort zuerst einmal die Unterobjekte von TForm verschieden seien können und man z.B. kein TLabel von einer TForm ableiten kann. Diese Hierachie kommt auch zustande weil das TForm Objekt ein Visueller Container ist in den man andere Objekte stecken kann.

Mfg HalloDu

Zu deiner Bemerkung: Die Typen müssen auch so stehen, also letzter Type muss als erstes definiert werden also: 1.Wuestenjeep, 2.Jepp, 3. PKW

EDIT: Und falls du Together hast kannst du Hierachie mit Verebung auch viel besser verwalten als mit deinem Konzept, dass ja nunmal sehr aufwendig ist.

[DGL-luke]

Das hat aber einen ganz anderen Aufbau! :warn:

Das ist ja keine Klassenhierarchie.

Zwischen
Fahrzeug->PKW->BMW->Z3
besteht doch ein ganz anderer zusammenhang als zwischen
root->node1->properties->name

:shock:

@Dein Problem: "forward declaration"

Delphi-Quellcode:

type
  T1 = class;
  T2 = class
    t1_ding: T1
  end;
  T1 = class
    t2_ding: T2;

Ansonsten, das bei dir ja nur in eine richtung geht, kannst fus einfach umdrehen und zuerst TWüstenAusgrabungsPyramidenFallenAusweichBrückenba uJeep deklarieren :wall:

[Sadum]

Zitat:

Zitat von DGL-luke

@Dein Problem: "forward declaration"

Delphi-Quellcode:

type
  T1 = class;
  end;
  T2 = class;
    t1_ding: T1;
  end;
  T1 = class
    t2_ding: T2;
  end;

Leider nimmt Delphi bei mir so ein Konstrukt nicht. -> Meldung: Bezeichner redefiniert!

Und mit

Delphi-Quellcode:

type
  Tjeep = class
  public
      procedure fahren;
  end;

type
  Tpkw = class
  public
      gelaendeindex : integer;
      jeep : Tjeep;
  end;

implementation

procedure Tjeep.fahren;
begin
    showmessage ('Jeep fährt'+inttostr(gelaendeindex)); // Fehler
end;

habe ich wie gesagt das Problem, dass Tjeep.fahren nicht auf Variablen des übergeorneten Objekts (gelaendeindex) zugreifen kann.

[DGL-luke]

Delphi-Quellcode:

type
  T1 = class;
  end;
  T2 = class;
    t1_ding: T1;
  end;
  T1 = class
    t2_ding: T2;
  end;

Das ist nicht das, was ich vorgeschlagen hatte :warn:

[HalloDu]

Ich hab jetzt mal kurz ein Beispiel, wie du das haben möchtest geschrieben, aber dabei ist mir aufgefallen, dass auch die Zeilen sehr lang werden.
Hier ist das Beispiel :coder2:

EDIT: An deinem Beispiel siehtst du auch wie unpraktisch dein Konzept ist, denn du kannst nicht auf Variablen und Methoden von Übergeorneten Objekten zugreifen, was bei Vererbung in den meisten Fällen möglich ist.