[OOP]: sinnvolle Vererbung

[mytar]

Vielen Danke für die Posts! :-D

Bedanke mich bei (alphabetisch):

• Bowler
• maximov
• Phoenix
• Stevie

Zitat:

Zitat von Stevie

Ja, sicher, ich bin aber davon ausgegangen, dass er von TMyList ableiten möchte ohne dass er dort irgendwas ändert und trotzdem auch das Wurzel-Objekt eine vom alten Wurzel-Objekt abgeleitete Klasse hat!

Bitte helft mir nochmal! :-D

Danke

[Stevie]

Zitat:

Zitat von mytar

Zitat:

Zitat von Stevie

Ja, sicher, ich bin aber davon ausgegangen, dass er von TMyList ableiten möchte ohne dass er dort irgendwas ändert und trotzdem auch das Wurzel-Objekt eine vom alten Wurzel-Objekt abgeleitete Klasse hat!

Bitte helft mir nochmal! :-D

Wenn du das auf meine Aussage beziehst - ich meinte damit, bzw ich ging von Folgendem aus:
Du hast die Klasse TMyList mit Wurzel als TKnoten vorgegeben und kannst oder darfst sie nicht mehr im Design verändern.
Du möchtest davon eine Klasse ableiten, die aber Knoten als TNewKnoten implementiert.

[mytar]

Zitat:

Zitat von Stevie

Wenn du das auf meine Aussage beziehst - ich meinte damit, bzw ich ging von Folgendem aus:
Du hast die Klasse TMyList mit Wurzel als TKnoten vorgegeben und kannst oder darfst sie nicht mehr im Design verändern.
Du möchtest davon eine Klasse ableiten, die aber Knoten als TNewKnoten implementiert.

Genau, allerdings hab ich dann nocht TMyNewList. Jezt möchte ich die implementierten Methoden von der Mutterklasse TMyList verwenden, diese sind aber alle mit TKnoten implementiert, ich möchte nun eben die Methoen der Mutterklasse vont TMyList auf TNewKnoten anwenden.

Ich hoffe es sich verständlich. :?

[Stevie]

Ich hab dir mal ein kleines Beispiel zusammengebastelt:

Delphi-Quellcode:

{...}

type
  TKnoten = class
    FZahl: Integer;
  public
    property Zahl: Integer read FZahl write FZahl;
  end;

  TMyList = class
    FWurzel: TKnoten;
  public
    constructor Create;
    destructor Destroy; override;
    function Verdopple: Integer;
    property Wurzel: TKnoten read FWurzel write FWurzel;
  end;

  // WICHTIG: Jeder Zugriff auf ererbte Eigenschaften muss über das LinkedObject laufen
  TNewKnoten = class(TKnoten)
    FText: string;
    FLinkedObject: TKnoten;
  private
    function GetZahl: Integer;
    procedure SetZahl(const Value: Integer);
  public
    constructor Create(LinkedObject: TKnoten = nil);
    destructor Destroy; override;
    property Text: string read FText write FText;
    property Zahl: Integer read GetZahl write SetZahl;
  end;

  TMyNewList = class(TMyList)
    FWurzel: TNewKnoten;
  public
    constructor Create;
    destructor Destroy; override;
    property Wurzel: TNewKnoten read FWurzel write FWurzel;
  end;

{...}

implementation

{ TMyList }

constructor TMyList.Create;
begin
  FWurzel := TKnoten.Create;
end;

destructor TMyList.Destroy;
begin
  FreeAndNil(FWurzel);
  inherited;
end;

function TMyList.Verdopple: Integer;
begin
  Result := FWurzel.Zahl * 2;
end;

{ TNewKnoten }

constructor TNewKnoten.Create(LinkedObject: TKnoten = nil);
begin
  FLinkedObject := LinkedObject;
end;

destructor TNewKnoten.Destroy;
begin
  FLinkedObject := nil;
end;

function TNewKnoten.GetZahl: Integer;
begin
  if Assigned(FLinkedObject) then
    Result := FLinkedObject.Zahl
  else
    Result := FZahl;
end;

procedure TNewKnoten.SetZahl(const Value: Integer);
begin
  if Assigned(FLinkedObject) then
    FLinkedObject.Zahl := Value
  else
    FZahl := Value;
end;

{ TMyNewList }

constructor TMyNewList.Create;
begin
  inherited;
  FWurzel := TNewKnoten.Create(TMyList(Self).Wurzel);
end;

destructor TMyNewList.Destroy;
begin
  FreeAndNil(FWurzel);
  inherited;
end;

{...}

Somit hast du dann eigentlich zwei Objekte (beide jeweils private und somit gekapselt und nur über properties ansprechbar!), wobei das zweite die ererbten Methoden, Eigenschaften von dem gelinkten Objekt verwendet. Sommit kannst du Wurzel in TMyNewList verändern und dann eine aus TMyList ererbte Funktion aufrufen, die irgendwas mit Wurzel macht. Anschließend kannst du die veränderten Werte von Wurzel in TMyNewList wieder abrufen.

[mytar]

Danke, Stevie! :-D

Phoenix hat mir folgende PN geschickt:

Zitat:

Zitat von Phoenix

Binde mal die Unit Classes in eine Deiner units ein, setze den Cursor in die Unit und drücke Strg + Enter. Damit macht Delphi dann den Sourcecode der VCL auf.

Dort Such mal nach den beiden Klassen TCollection und TCollectionItem.

Schau Dir mal die Methoden TCollection.Create und TCollection.Add an.

Dort wird nämlich eigentlich genau das gemacht, was Du willst. Bessere Beispiele kannst Du eigentlich nicht finden.

Das werd ich auch mal versuchen, Danke! :lol:

[Stevie]

Klar, wenn man beide Klassen neu erstellt, ist das der beste Weg.
Allerdings geht das eben nicht, wenn man eine schon bestehende Klasse hat, die man erweitern will.

[mytar]

Ich danke allen Postern, für die vielen Antworten. Danke :-D

In meinem Falls werde ich Klassenreferenztypen (class of) verwenden, aber auch der Vorschlag von Stevie werd ich mir merken.

TCollection und TCollectionItem sind ideale Beispiele für Klassenreferenztypen (Phoenix).

Hier noch ein alter Thread, bezüglich "class of":
Was bedeutet "class of"

Der Thread ist [erledigt], Danke :-D