[OOP]: Methode (mit Parameter) überschreiben

[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