overload, override, virtual, inherited

[Char]

Hallo :)

Könnte mir eventuell diese vier Begriffe (overload, override, virtual, inherited) in Verbindung mit Delphi erklären? Vor allem angewendet? Ich habe zwar die Hilfe gelesen, aber so ganz versteh ich das nicht.

Ein Link, unter dem es gut erklärt wird, wäre mir natürlich auch recht.

Ich hoffe ihr könnt mir helfen.

[Phoenix]

- overload
kennzeichnet überladene Methoden. D.H. gleichlautende Funktionsaufrufe, mit verschiedenen Parametern.

- override
kennzeichnet überschriebene Methoden, die also in einer abgeleiteten Klasse erneut implementiert werden

- virtual und dynamic
deklarieren Methoden, die in abgeleiteten Klassen überschrieben werden dürfen

- inherited
kennzeichnet eine Methode der Basisklasse. Beispiel: TWasauchimmer.Create ist die überschriebene Methode von TObject.Create. Inherited Create; in TWasauchimmer ruft die Create - Methode von TObject auf.

[Dagon]

Mit Overload kannst du mehrere Funktionen mit dem gleichen Namen, aber unterschiedlicher Parameterliste haben:

Delphi-Quellcode:

function Addiere(Zahl1, Zahl2: Integer): Integer; overload;
function Addiere(Zahl1, Zahl2, Zahl3: Integer): Integer; overload;

Mit Virtual bzw. dynamic definierst du eine Virtuelle Methode, die mit override einer abgeleiteten Klasse überschrieben werden kann.

Mit inherited rufst du die Vorgängermethode auf.

[Char]

Also wenn ich eine Klasse TEigeneKlasse habe (abgeleitet von TObject) und die einen Constructor namens Create hat (ist ja so üblich:

Delphi-Quellcode:

Instanz: TEigeneKlasse;

Delphi-Quellcode:

procedure Create;

So würde Instanz.create; würde jetzt TObject.create aufrufen und so:

Delphi-Quellcode:

procedure Create; override;

würde Instanz.create; TEigeneKlasse.create aufrufen, habe ich das so richtig verstanden?

Und wenn jetzt im Constructor von TEigeneKlasse

Delphi-Quellcode:

procedure Create; override;

noch Inherited; drin steht, dann wird nicht nur TEigeneKlasse.create sondern auch TObject.create; aufgerufen.

Stimmt das so?

[Dagon]

Das stimmt so nicht ganz, zumindest nicht wenn man es auf dein Beispiel bezieht. Du kannst den Konstruktor von TObject nicht überschreiben, da Create keine virtuelle Methode ist!
Aber du kannst mit

Delphi-Quellcode:

TEigeneKlasse.Create;
begin
  inherited;
  // Eigene Initialisierung
end;

zuerst die Methode Create von TObject aufrufen und dann selber noch "Dinge" hinzufügen.

[Char]

Das versteh ich eben nicht, ich dachte wenn ich TEigeneKlasse.create aufrufe, wird einfach TObject.create aufgerufen, selbst wenn ich was eigenes in TEigeneKlasse.create geschrieben habe.

Was macht nun:

Delphi-Quellcode:

procedure TEigeneKlasse.create;
begin

Hallo := 123;    { <- nur als Beispiel jetzt }

end;

Ruft diese Prozedur
a) nur TObject.create; auf,
b) erstellt sie eine Instanz von TEigeneKlasse und ändert den Inhalt der Variablen,
c) erstellt sie KEINE Instanz von TEigeneKlasse, ändert aber den Inhalt der Variablen (macht keinen Sinn oder?),
d) ändert es den Inhalt der Variablen und ruft TObject.create auf?

Ich dachte eben a)...

[Christian Seehase]

Moin Char,

Zitat:

Zitat von Char

Das versteh ich eben nicht, ich dachte wenn ich TEigeneKlasse.create aufrufe, wird einfach TObject.create aufgerufen, selbst wenn ich was eigenes in TEigeneKlasse.create geschrieben habe.

Was macht nun:

Delphi-Quellcode:

procedure TEigeneKlasse.create;
begin

Hallo := 123;    { <- nur als Beispiel jetzt }

end;

Ruft diese Prozedur
a) nur TObject.create; auf,
b) erstellt sie eine Instanz von TEigeneKlasse und ändert den Inhalt der Variablen,
c) erstellt sie KEINE Instanz von TEigeneKlasse, ändert aber den Inhalt der Variablen (macht keinen Sinn oder?),
d) ändert es den Inhalt der Variablen und ruft TObject.create auf?

Ich dachte eben a)...

a)
Nein, Du rufst hier nirgends die ererbte Methode des Vorfahren auf
b)
Nein, der Konstrukter erstellt niemals eine Instanz seiner eigenen Klasse, sondern wird zum initialisieren beim Bilden einer Instanz aufgerufen
c)
Jain, sie erstellt keine Instanz (Ja) und ändert den Inhalt der Variablen nicht (Nein)
d)
Jain, der Variableninhalt wird geändert (Ja), TObject.Create wird nicht aufgerufen (Nein)

Der Konstruktur dient einzig und allein dazu eventuell erforderliche Initialisierungen vorzunehmen, wenn man eine Instanz der Klasse bildet.
Da dies auch für die Vorfahrklasse gilt, sollte man hier auch, mittels inherited, den Konstruktor des Vorfahren aufrufen. Dies geschieht nicht automatisch.

Sollte es nicht erforderlich sein, dass Deine abgeleitete Klasse etwas initialisiert, brauchst Du auch keinen Konstruktor anzugeben. Dann wird automatisch der des Vorfahren genommen, wenn Du eine Instanz bildest.

[Phoenix]

C ist die richtige Antwort.
Aber Merke: nicht create selber erstellt die Instanz!



Nochmal langsam:

Delphi-Quellcode:

   myObject = class
   public
      constructor create;
   end;

   my2ndObject = class
   public
      constructor create; override;
   end;

Sodele:

Delphi-Quellcode:

constructor myObject.Create;
begin
   ShowMessage('Instanz von myObject erzeugt...');
end;


constructor my2ndObject.Create;
begin
   ShowMessage('Instanz von my2ndObject erzeugt...');
end;

Wie leicht zu erkennen ist, ruft nun ein:

Delphi-Quellcode:

procedure Test;
var
   obj: my2ndObject;
begin
   obj := my2ndObject.Create;
end;

nur den Konstruktor von my2ndObject auf. Es erscheint also _nicht_ die Nachricht, das ein myObject erzeugt wurde. Der Konstruktor von myObject wird nur dann ausgeführt, wenn Du im aufgerufenen Konstruktor (my2ndObject.Create) auch ein inherited aufrufst.

[Christian Seehase]

Moin Phoenix,

Zitat:

Zitat von Phoenix

C ist die richtige Antwort.

stimmt auch wieder. Diese ja/nein Inhalt hat mich irrtiert :? :wink:

[Dagon]

@ Phoenix: Hätte das Beispiel nicht etwa so aussehen müssen?:

Delphi-Quellcode:

type
  myObject = class
  public
    constructor create; virtual;
  end;

  my2ndObject = class(myObject)
  public
    constructor create; override;
  end;