[OOP]: sinnvolle Vererbung

[mytar]

Schon seit längerer Zeit versuche ich mich in die OOP einzuarbeiten.

Nun hab ich aber oft Probleme mit der Vererbung. Ich kenne die meisten Compilerdirektiven (virtual, override usw.), hab aber trotzdem Probleme.

Neuerdings hab ich mir eine Liste zusammengeproggt, und das meiner Klasse TMyList implementiert.
Dort brauche ich natürtlich auch eine Wurzel:

Delphi-Quellcode:

TMyList = class
private
 Wurzel: TKnoten;
public
 procedure Hinzufuegen;
 {...}
end;

Nun hab ich aber eine Weiterentwicklung von TKnoten gemacht, natürlich durch Vererbung.
Diese Weiterentwicklung von TKnoten möchte ich nun in eine weitere Listenklasse implementieren.

Delphi-Quellcode:

TMyNewList = class(TMyList)
private
 Wurzel: TNewKnoten;
public
 {...}
end;

Ihr sehr jetzt mein Problem mit der Wurzel, und ich habe ja auch Hinzufuegen von TMyList geerbt.
Leider arbeitet die Prozedur Hinzufügen mit TKnoten. Muss ich jetzt die Methode Hinzufügen in TMyNewList neu implentieren, oder kann ich mit inherited auf Hinzufügen zugreifen, allerdings mit Instanzen von TNewKnoten?

[Stevie]

Da TMyList nur TKnoten kennt, musst du der Prozedur eine "runtergecastete" Instanz von TMyKnoten übergeben -->

Delphi-Quellcode:

TMyList = class
private
Wurzel: TKnoten;
public
procedure Hinzufuegen(var Neu: TKnoten);
{...}
end;

TMyNewList = class(TMyList)
private
Wurzel: TNewKnoten;
public
{...}
end;

...

//Aufruf
var
  Liste: TMyNewList;
  NeuerKnoten: TNewKnoten;
begin
  ...
  NeuerKnoten := TNewKnoten.Create;
  Liste.Hinzufügen(NeuerKnoten); //von Typ TNewKnoten, der von TKnoten abstammt
  ...

Wenn du auf irgendwas zugreifen musst, was in TNewKnoten enthalten ist, dann musst du die Proezdur neu implementieren, vielleicht geht es sogar so:

Delphi-Quellcode:

procedure TMyNewList.Hinzufuegen((var Neu: TNewKnoten);
begin
  inherited Hinzufuegen; // weiß nicht genau, vielleicht auch so: inherited Hinzufuegen(Neu);
  //Mach irgendwas mit Neu als TNewKnoten
end;

[mytar]

Muss ich Wurzel: TNewKnoten üverhaupt in TMyNewList neu implementieren, oder kann ich Wurzel von TMyList irgendwie manipulieren?

[Bowler]

Müsstest Du können. Allerdings hast du Wurzel:TKnoten als private deklariert, deswegen ist das nur in dieser Klasse sichtbar. Damit die Ableitungen (TMyNewList) auf das Wurzel-Attribut aus der Mutterklasse zugreifen kann, musst du es als protected oder public deklarieren:

Delphi-Quellcode:

TMyList = class
protected
Wurzel: TKnoten;
public
procedure Hinzufuegen(var Neu: TKnoten);
{...}
end;

nun ist Wurzel vom Typ TKnoten auch in den abgeleiteten Klassen sichtbar.

[Stevie]

Zitat von Bowler:

nun ist Wurzel vom Typ TKnoten auch in den abgeleiteten Klassen sichtbar.

Ja, aber immer nur noch als TKnoten-Objekt!!

Zitat von mytar:

Muss ich Wurzel: TNewKnoten üverhaupt in TMyNewList neu implementieren, oder kann ich Wurzel von TMyList irgendwie manipulieren?

Du musst folgendes bedenken, wenn eine Methode aus TMyList aufgerufen wird und auf Wurzel zugegriffen wird, dann ist das ein TKnoten-Objekt, ist die Methode aber in der TMyNewList, dann ist Wurzel ein TNewKnoten-Objekt, beides sind unterschiedliche und unabhängige Objekte. Du könntest natürlich versuchen, das neue Wurzel-Objekt über eine Property auf das alte zeigen zu lassen (vorrausgesetzt, du beachtest den Rat von Bowler):

Delphi-Quellcode:

function TMyNewList.GetWurzel: TNewKnoten;
begin
  Result := Wurzel;
  // Eigenschaften kopieren...
  Result.Irgendwas := TMyList(Self).Wurzel.Irgendwas;
  // vielleicht geht sogar Result.Irgendwas := inherited Wurzel.Irgendwas oder so ähnlich??? 
end;

[mytar]

Zitat von Stevie:

Da TMyList nur TKnoten kennt, musst du der Prozedur eine "runtergecastete" Instanz von TMyKnoten übergeben

Wie meinst du das mit runtercasten!

Was ist der Unterschied zwischen TMyNewList(MyList) und
MyList as TMyNewList ?

[Stevie]

Zitat von mytar:

Zitat von Stevie:

Da TMyList nur TKnoten kennt, musst du der Prozedur eine "runtergecastete" Instanz von TMyKnoten übergeben

Wie meinst du das mit runtercasten!

Was ist der Unterschied zwischen TMyNewList(MyList) und
MyList as TMyNewList ?

Mit runtercasten meinte ich auf den Vorfahren casten.

Zitat von Die OH:

Der Operator as führt eine Typumwandlung mit Laufzeitprüfung durch.

Wenn du wie im ersten Beispiel castest, dann gibt's ne Zugriffsverletztung, wenn die Klassen nicht stimmen, aber bei unserem Beispiel braucht ja nix überprüft werden, denn wir wissen ja, was für Klassen wir haben.

[Phoenix]

Schau Dir dazu doch auch mal in der Unit Classes.pas der VCL (source liegt Deiner Enterprise ja bei) die beiden Klassen TCollection und TCollectionItem an.

Dort ist das so implemetiert, das Du beim erzeugen der (abgeleiteten) Collection/Liste den Typ (also die Klasse) der Items mitgibst. Diese werden dann durch eine Classfactory als entsprechende Objekte hinzugefügrt / created.

[Bowler]

Zitat von mytar:

Muss ich Wurzel: TNewKnoten üverhaupt in TMyNewList neu implementieren, oder kann ich Wurzel von TMyList irgendwie manipulieren?

Ja, daraus habe ich gelesen, dass er sich das ableiten der Klasse TNewKnoten sparen will, und direkt auf der TKnoten-Klasse arbeiten will.

Wobei es mittels Polymorphie auch funktionieren müsste, wenn TNewKnoten von TKnoten abgeleitet wird. Dann müsste er in der TMyNewList ein Objekt von TNewKnoten in dem Wurzel-Attribut von TKnoten instanzieren können.

[mytar]

@Bowler: Wie bitte? Könntest du das etwas einfacher erklären?

Danke!

P.S.: Bitte nicht im Konjunktiv schreiben!