[OOP]: Methode (mit Parameter) überschreiben

[mytar]

• Ich hab neuerdings in der VCL etwas herumgestöbert, und hab da bei allen public-Methoden kein override gesehen, obwohl die Basisklasse die selbe Methode im public-Teil hat.
  Wie soll ich das verstehen?
• Ich hab in einer Klasse ein Methode erstellt. Ich hab diese Klasse nun beerbt und wiederum die selbe Methode verwendet nur mit anderen Parametern. Ich hab schon von reintroduce gelesen, allerdings überschreibt das die geerbte Methode ohne das ich auf diese über inherited zugreifen kann, also nicht das richtige für mich. Hier der Code:
  
  Delphi-Quellcode:

  TListe = class
  {...}
  public
  function Add_Knoten(Knoten: TKnoten): TKnoten;
  end;
  
  TNewListe = class(TListe)
  {...}
  public
  function Add_Knoten(Knoten: TNewKnoten): TNewKnoten;
  end;
  
  function TListe.Add_Knoten(Knoten: TKnoten): TKnoten;
  begin
  {...}
  end;
  
  function TNewListe.Add_Knoten(Knoten: TNewKnoten): TNewKnoten;
  begin
   Result := TNewKnoten(inherited Add_Knoten(TKnoten(Knoten))); //Löst immer einen Fehler aus
  end;

  Was mache ich falsch?

[dango]

Hallo

Zitat:

Delphi-Quellcode:

function TListe.Add_Knoten(Knoten: TKnoten): TKnoten;
begin
{...}
end;

function TNewListe.Add_Knoten(Knoten: TNewKnoten): TNewKnoten;
begin
Result := TNewKnoten(inherited Add_Knoten(TKnoten(Knoten))); //Löst immer einen Fehler aus
end;

Die Typumwandlung ist falsch ! Ein Downcast von TNewKnoten nach TKnoten ist möglich, Du versuchst hier aber einen Upcast von TKnoten nach TNewKnoten !

Gruß
Daniel

[Muetze1]

Moin!

Grundlegendes: Ich gehe davon aus, das TNewKnoten von TKnoten abgeleitet ist! - da dies vorher nicht geklärt wurde.

Wenn das der Fall ist, dann einfach so:

Code:

function TListe.Add_Knoten(Knoten: TKnoten): TKnoten;
begin
{...}
end;

function TNewListe.Add_Knoten(Knoten: TNewKnoten): TNewKnoten;
begin
Result := ( inherited Add_Knoten(Knoten) As TNewKnoten ); //Löst immer einen Fehler aus
end;

Dabei gehe ich davon aus, das Add_Knoten keine Instanz anlegt sondern eine vorhandene oder die übergebene TNewKnoten Instanz zurück gibt. Wenn es keine Instanz von TNewKnoten ist, dann schlägt die in der As Abfrage enthaltene Is Abfrage fehl und Result wird nicht gefüllt bzw. mit NIL. Daher gibt er entweder eine eindeutige TNewKnoten Instanz zurück oder Nil bzw. einen Zufallswert.

Beim Aufruf kannst du direkt die TNewKnoten Instanz angeben, weil TNewKnoten von TKnoten abgeleitet ist.

MfG
Muetze1

[GuenterS]

ich denke, dass diese zwei zwar gleichnamigen Methoden wie zwei verschiedene gehandhabt werden, daher wird er auch keine inherited finden können, da sich die zwei durch die Parameter unterscheiden.

[Muetze1]

Moin!

Nein, da hat er keine Probleme, da er die andere Methode findet, weil es die Basisklasse von dem TKnoten Objekt enthält. Das übergeben Objekt hat ja schon den Typ TNewKnoten, daher hat er da kein Problem. Wenn der Parameter einen niedrigeren Typ hätte (z.B. TObject), dann würde er fehlschlagen und meckern...

MfG
Muetze1

[mytar]

Danke für die Antworten! :-D

Nochmals auf meine 1. Frage zurückzukommen:

Zitat:

Zitat von mytar

• Ich hab neuerdings in der VCL etwas herumgestöbert, und hab da bei allen public-Methoden kein override gesehen, obwohl die Basisklasse die selbe Methode im public-Teil hat.
  Wie soll ich das verstehen?

Danke

[Dax]

Verstehe es doch so: Borland nimmt es nicht so genau..

[mytar]

Wozu gibt es dann override?
Wird dieses Überschreiben überall außer im public-Teil verwendet?
:gruebel:

[mytar]

*push* :angel:

[d3g]

Zitat:

Zitat von mytar

Wozu gibt es dann override?

Um zwei Prozeduren/Funktionen gleichen Namens aber mit unterschiedlichen Parametern im gleichen Gültigkeitsbereich haben zu können.

Delphi-Quellcode:

type
  TExample = class(TObject)
  public
    constructor Create();
    constructor Create(o: TObject); override;
  end;

[mytar]

Ich verstehe jetzt gar nichts mehr. :-D

Ich dachte dafür gibt es overload?

[Robert_G]

Zitat:

Zitat von mytar

Ich verstehe jetzt gar nichts mehr. :-D

Ich dachte dafür gibt es overload?

Da hast du natürlich recht.
Mit override überschreibst du eine virtuelle oder abstrakte Methode der Basisklasse.

[d3g]

Ja, hast Recht... Ich sollte mehr schlafen.

[mytar]

Kann mir aber trotzdem jemand meine Frage beantworten? :-D

[paelesoft]

Haben die Methoden der

Zitat:

Basisklasse

denn ein virtual ?

Edit: Denn ohne virtual / dynamic kein override.

[mytar]

*push* :angel:

[MaBuSE]

Zitat:

Zitat von mytar

*push* :angel:

*pop* :angel:
Steht alles in der Onlinehilfe.
(Da steht sogar noch viel mehr. :mrgreen:)

in der Delphi7 Hilfe steht

Unterschiede zwischen Überschreiben und Verdecken
Wenn in einer Methodendeklaration dieselben Bezeichner- und Parameterangaben wie bei einer geerbten Methode ohne die Anweisung override angegeben werden, wird die geerbte Methode durch die neue Deklaration verdeckt. Beide Methoden sind jedoch in der abgeleiteten Klasse vorhanden, in der die Methode statisch gebunden wird. Ein Beispiel:

Delphi-Quellcode:

type
  T1 = class(TObject)
    procedure Act; virtual;
  end;
  T2 = class(T1)
    procedure Act;  // Act ist neu deklariert, aber nicht überschrieben
  end;
var
  SomeObject: T1;
begin
  SomeObject := T2.Create;
  SomeObject.Act;  // T1.Act wird aufgerufen
end;

in der Delphi7 Hilfe steht

Statische Methoden
Methoden sind standardmäßig statisch. Beim Aufruf bestimmt der deklarierte Typ (also der Typ zur Compilierzeit) der im Aufruf verwendeten Klassen- bzw. Objektvariablen, welche Implementierung aktiviert wird. Die Draw-Methoden im folgenden Beispiel sind statisch:

Delphi-Quellcode:

type
  TFigure = class
    procedure Draw;
  end;
  TRectangle = class(TFigure)
    procedure Draw;
  end;

Ausgehend von diesen Deklarationen zeigt das folgende Beispiel, wie sich Aufrufe statischer Methoden auswirken. Im zweiten Aufruf von Figure.Draw referenziert die Variable Figure ein Objekt der Klasse TRectangle. Es wird jedoch die Draw-Implementierung in TFigure aufgerufen, weil Figure als TFigure deklariert ist.

Delphi-Quellcode:

var
  Figure: TFigure;
  Rectangle: TRectangle;
begin
  Figure := TFigure.Create;
  Figure.Draw;  // Figure.Draw wird aufgerufen
  Figure.Destroy;
  Figure := TRectangle.Create;
  Figure.Draw;  // TFigure.Draw wird aufgerufen
  TRectangle(Figure).Draw;  // TRectangle.Draw wird aufgerufen
  Figure.Destroy;
  Rectangle := TRectangle.Create;
  Rectangle.Draw;  // TRectangle.Draw wird aufgerufen
  Rectangle.Destroy;
end;

in der Delphi7 Hilfe steht

Virtuelle und dynamische Methoden
Mithilfe der Direktiven virtual und dynamic können Methoden als virtuell oder dynamisch deklariert werden. Virtuelle und dynamische Methoden können im Gegensatz zu statischen Methoden in abgeleiteten Klassen überschrieben werden. Beim Aufrufen einer überschriebenen Methode bestimmt nicht der deklarierte, sondern der aktuelle Typ (also der Typ zur Laufzeit) der im Aufruf verwendeten Klassen- bzw. Objektvariable, welche Implementierung aktiviert wird.

Um eine Methode zu überschreiben, braucht sie nur mit der Direktiven override erneut deklariert zu werden. Dabei müssen Reihenfolge und Typ der Parameter sowie der Typ des Rückgabewertes (falls vorhanden) mit der Deklaration in der Vorfahrklasse übereinstimmen.

Im folgenden Beispiel wird die in der Klasse TFigure deklarierte Methode Draw in zwei abgeleiteten Klassen überschrieben:

Delphi-Quellcode:

type
  TFigure = class
    procedure Draw; virtual;
  end;
  TRectangle = class(TFigure)
    procedure Draw; override;
  end;
  TEllipse = class(TFigure)
    procedure Draw; override;
  end;

Ausgehend von diesen Deklarationen zeigt der folgende Programmcode, wie sich der Aufruf einer virtuellen Methode durch eine Variable auswirkt, deren aktueller Typ zur Laufzeit geändert wird.

Delphi-Quellcode:

var
  Figure: TFigure;
begin
  Figure := TRectangle.Create;
  Figure.Draw;  // TRectangle.Draw wird aufgerufen
  Figure.Destroy;
  Figure := TEllipse.Create;
  Figure.Draw;  // TEllipse.Draw wird aufgerufen
  Figure.Destroy;
end;

Nur virtuelle und dynamische Methoden können überschrieben werden. Alle Methoden können jedoch überladen werden (siehe Methoden überladen).

Unterschiede zwischen virtuellen und dynamischen Methoden
Virtuelle und dynamische Methoden sind von der Semantik her identisch. Sie unterscheiden sich nur bei der Implementierung der Aufrufverteilung zur Laufzeit. Virtuelle Methoden werden auf Geschwindigkeit, dynamische Methoden auf Code-Größe optimiert.

Im Allgemeinen kann mit virtuellen Methoden polymorphes Verhalten am effizientesten implementiert werden. Dynamische Methoden sind hilfreich, wenn in einer Basisklasse eine große Anzahl überschreibbarer Methoden deklariert ist, die von vielen abgeleiteten Klassen geerbt, aber nur selten überschrieben werden.

Hinweis
Verwenden Sie dynamische Methoden nur, wenn sich daraus ein nachweisbarer Nutzen ergibt. Allgemein sollten Sie virtuelle Methoden verwenden.

[MaBuSE]

Falls Deine Frage beantwortet ist, nicht vergessen mit dem http://www.delphipraxis.net/template...t_answered.gif - Button oben auf der Seite die Frage als beantwortet zu markieren.
Danke