Hallo und danke erst einmal fuer die raschen Antworten.
Dabei entsteht die Warnung. Auch bei overload (da ich ihn ja ueberlade).
An genau dieser Stelle hast Du die oben aufgeführten Beispiele nicht genau angesehen. Das Überladen von Funktionen und Prozeduren, den sogenannten Methoden eines Objekts wird im Deklarationsteil des Objekts abgegeben und unterstützt die Polymorphie. Overload darf nicht mit dem Überschreiben eines Konstruktors oder Destruktors, bzw. jeder anderen virtuellen Methode verwechselt werden. Beim Überladen wird eine weitere oder auch mehrere weitere Methode/Methoden eingeführt, die eine unterschiedliche Parameterliste aufweisen.
Siehe auch bei
Delphi-Treff folgendes:
Zitat:
[...]
Prozeduren und Funktionen überladen
In Delphi ist es möglich, im selben Gültigkeitsbereich mehrere Routinen mit identischem Namen zu deklarieren. Dieses Verfahren wird "Überladen" genannt.
Überladene Routinen müssen mit der Direktiven overload deklariert werden und unterschiedliche Parameterlisten haben.
Delphi-Quellcode:
function Divide(x, y: real): real; overload;
begin
result := x / y;
end;
function Divide(x, y: integer): integer; overload;
begin
result := x div y;
end;
Diese Deklarationen definieren zwei Funktionen namens Divide, die Parameter unterschiedlicher Typen entgegennehmen. Wenn Divide aufgerufen wird, ermittelt der Compiler die zu verwendende Funktion durch Prüfung des übergebenen Parametertyps.
Divide(6.0, 3.0) ruft beispielsweise die erste Divide-Funktion auf, da es sich bei den Argumenten um reelle Zahlen handelt, auch wenn der Nachkommateil Null ist.
Überladene Methoden müssen sich deshalb entweder in der Anzahl der Parameter oder in den Typen dieser Parameter signifikant unterscheiden.
Wenn Du allerdings eine virtuelle Methode, bzw. einen Konstruktor oder Destruktor überschreiben möchtest, so verwendest Du den Befehl OVERRIDE.
Um sicherzustellen das dennoch Dein Objekt erzeugt wird, rufst Du die ursprüngliche Methode mit inherited auf. Also beim Konstruktor inherited aufrufen und dann Deinen eigenen Code abarbeiten lassen. Beim Destruktor zuerst Deinen eigenen Code ablaufen lassen udn inherited zum Schluss (Erklärt sich von selbst wenn man bedenkt, dass man in nicht vorhandenen Objekten keine Änderungen durchführen kann).
Delphi-Quellcode:
TBasisClass = TObject
constructor Create(AOwnder: TComponent); virtual;
destructor Destroy; virtual;
end;
TMyClass = TBasisClass
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
function DoSomeThing(Left,Right: Integer): Boolean; Overload;
function DoSomeThing(Left,Right: String; Up,Down: Integer): Boolean; Overload;
end;
constructor TMyClass.Create(AOwner: TComponent);
begin
inherited;
{ Eigebner Quellcode der abgearbeitet werden soll }
end;
destructor TMyClass.Destroy;
begin
{ eigener Code der abgearbeitet werden soll }
inherited;
end;
function TMyClass.DoSomeThing(Left,Right: Integer): Boolean;
begin
{ DoSomeThing }
end;
function TMyClass.DoSomeThing(Left,Right: String; Up,Down: Integer): Boolean;
begin
{DoSomeThingElse }
end;